home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / c / xw2.000 / xw2 / xw / csource / x3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-03  |  94.6 KB  |  2,935 lines
  1.  
  2.  
  3. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  4. /*                                                                           */
  5. /*                                                                           */
  6. /*   Modul X3.C                                                              */
  7. /*                                                                           */
  8. /*                                                                           */
  9. /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  10.  
  11.  
  12. /* Header--------------------------------------------------------------------*/
  13.  
  14. #include "xbw.h"
  15.  
  16. /*  ---------------------Compiler-Modelle------------------------------------*/
  17.                       /* ---............Nicht möglich  */
  18.                       /* !!!............Noch zu machen */
  19.                       /* ???............unklar         */
  20.                       /* TC3............Turbo-C Version*/
  21.                       /*     GNU........32-Bit Version */
  22.                       /*         X11....X-Window       */
  23.  
  24.  
  25. /*{{{  XbWFWd_GetList(     ***    Liste aller Windownamen lesen*/
  26. int  XbWFWd_GetList(void){
  27.   int ii;  for (ii=1;ii<=XbWDWd_MaxWdw;ii++){  XbWVWd_Name[ii]=NULL; };
  28.   ii = 0;
  29.   XbWVDb_ActGrp1 = XbWFDb_FindGrp("WDW",NULL);
  30.   do {
  31.     ii++;
  32.     XbWVWd_Name[ii] = (char*)XbWFDb_VarInh(XbWVDb_ActGrp1,XbWDDb_Str,"WDW",0);
  33.     XbWVWd_Grp[ii] = XbWVDb_ActGrp1;
  34.  
  35.     if (ii == XbWDWd_MaxWdw-3){
  36.       XbWVWd_Name[ii]=NULL;
  37.       };
  38.     }
  39.   while ((XbWVDb_ActGrp1 = (XbWDDb_DbIVar  *)XbWFDb_NextGrp(XbWVDb_ActGrp1,NULL)) != NULL);
  40.   XbWVWd_MaxReg = ii;
  41.   XbWVWd_FoundNo = ii;
  42.   return(0);
  43.   };
  44. /*}}}  */
  45. /*{{{  XbWFWd_GetPara(     ***    Parameter eines Windows laden*/
  46. int  XbWFWd_GetPara(int nr, XbWDDb_DbIWdw  *TW){
  47.   XbWDDb_DbIVar  *TV;
  48.  
  49.   if (XbWVWd_Name[nr] == NULL) {return(0);};
  50.  
  51.   TW->nm = XbWVWd_Name[nr];
  52.   TV =     XbWVWd_Grp[nr];
  53.  
  54.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  55.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  56.  
  57.   TW->tp = (int *)XbWFDb_GetInh(TV,XbWDDb_Int);
  58.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  59.   TW->layer = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  60.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  61.   TW->nx = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  62.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  63.   TW->ny = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  64.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  65.   TW->sx = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  66.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  67.   TW->sy = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  68.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  69.   TW->wov = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  70.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  71.  
  72.   if ((TV->tp & XbWDDb_Typ) == XbWDDb_Int) {
  73.     TW->icn = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  74.     }
  75.   else {
  76.     TW->icn = (int *)XbWFDb_GetInh(TV,XbWDDb_Int);
  77.     };
  78.  
  79.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  80.  
  81.   if ((TV->tp & XbWDDb_Typ) == XbWDDb_Int) {
  82.     TW->bkc = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  83.     }
  84.   else {
  85.     TW->bkc = (int *)XbWFDb_GetInh(TV,XbWDDb_Int);
  86.     };
  87.  
  88.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  89.  
  90.   if ((TV->tp & XbWDDb_Typ) == XbWDDb_Int) {
  91.     TW->txc = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  92.     }
  93.   else {
  94.     TW->txc = (int *)XbWFDb_GetInh(TV,XbWDDb_Int);
  95.     };
  96.  
  97.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  98.  
  99.   if ((TV->tp & XbWDDb_Typ) == XbWDDb_Int) {
  100.     TW->bfc = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  101.     }
  102.   else {
  103.     TW->bfc = (int *)XbWFDb_GetInh(TV,XbWDDb_Int);
  104.     };
  105.  
  106.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  107.  
  108.   if ((TV->tp & XbWDDb_Typ) == XbWDDb_Int) {
  109.     TW->dfc = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  110.     }
  111.   else {
  112.     TW->dfc = (int *)XbWFDb_GetInh(TV,XbWDDb_Int);
  113.     };
  114.  
  115.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  116.   TW->wfx = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  117.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  118.   TW->wfe = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  119.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  120.   TW->bd = (int *)&( ((XbWDDb_DbIInt *)TV)->inh);
  121.   XbWFDb_ForWd(&TV,XbWDDb_DbISys);
  122.   TW->obj = (XbWDDb_DbIPtr*)&( ((XbWDDb_DbINPtr *)TV)->inh);
  123.   return(1);
  124.   };
  125. /*}}}  */
  126. /*{{{  XbWFWd_OvrLap(      ***    Check ob sich zwei Wdws ueberlappen*/
  127. int  XbWFWd_OvrLap(XbWDDb_DbIWdw *wtest, XbWDDb_DbIWdw *wb){
  128.   if (wtest == NULL) {goto is_not_overlapped;};
  129.   if (wb == NULL) {goto is_not_overlapped;};
  130.   if (wtest->nm == NULL) {goto is_not_overlapped;};
  131.   if (wb->nm == NULL) {goto is_not_overlapped;};
  132.   if (XbWFTb_CmpStr((char*)wtest->nm,(char*)wb->nm) == 0){ goto is_not_overlapped;};
  133.   if (((*wtest->icn) ) != 0) {goto is_not_overlapped;};
  134.   if (*wtest->nx  + *wtest->sx <= *wb->nx){goto is_not_overlapped;};
  135.   if (*wtest->nx >= *wb->nx  + *wb->sx){goto is_not_overlapped;};
  136.   if (*wtest->ny  + *wtest->sy <= *wb->ny){goto is_not_overlapped;};
  137.   if (*wtest->ny >= *wb->ny  + *wb->sy){goto is_not_overlapped;};
  138.   (*wtest->wov)=1;
  139.   if (!XbWVWd_AClos) {
  140.     return(0);
  141.     };
  142.   return(1);
  143.   is_not_overlapped:;
  144.   return(0);
  145.   };
  146. /*}}}  */
  147. /*{{{  XbWFWd_Hide(        ***    Ckeck ob ein Window ein anderes ganz verdeckt*/
  148. int  XbWFWd_Hide(XbWDDb_DbIWdw *wtest, XbWDDb_DbIWdw *wb){
  149.   if (((*wtest->icn) ) == 0) {
  150.     if (*wtest->nx  >= *wb->nx){
  151.       if (*wtest->ny >= *wb->ny){
  152.         if (*wtest->nx  + *wtest->sx <= *wb->nx + *wb->sx){
  153.           if (*wtest->ny + *wtest->sy <= *wb->ny  + *wb->sy){
  154.             /* wtest wird vollständig von wb überdeckt */
  155.  
  156.             *wtest->wov = 1;
  157.             *wtest->icn = 1;  /* iconizen */
  158.             return(1);
  159.             };
  160.           };
  161.         };
  162.       };
  163.     };
  164.   return(0);
  165.   };
  166. /*}}}  */
  167. /*{{{  XbWFWd_ReDisp(      ***    Window Rahmen und Inhalt zeichnen*/
  168. void  XbWFWd_ReDisp(void){
  169.   XbWFWd_Draw(); XbWFWd_Rebuild();
  170.   };
  171. /*}}}  */
  172. /*{{{  XbWFWd_Refresh(     ***    Window Rahmen zeichnen*/
  173. void  XbWFWd_Refresh(void){
  174.   int cstat = XbWVMs_CSet;
  175.   XbWFGr_CurOFF();
  176.   if (XbWVWd_W.nm != NULL) {
  177.     if ( (*XbWVWd_W.nx < 0) ) { /*  Window liegt zu weit links       */
  178.       *XbWVWd_W.nx = 0;
  179.       };
  180.     if ( (*XbWVWd_W.ny < 0) ) {     /* zu weit oben  */
  181.       *XbWVWd_W.ny = 0;
  182.       };
  183.     if (((*XbWVWd_W.icn) ) == 0) {
  184.       XbWFWd_Make(&XbWVWd_W);
  185.       };                                    /* Zeichne normales Fenster */
  186.     };
  187.   if (cstat) { XbWFGr_CurON(); };
  188.   };
  189. /*}}}  */
  190. /*{{{  XbWFWd_DrwASub(        ***    Unterroutine zu DrawAll*/
  191. void  XbWFWd_DrwASub(void){
  192.   XbWDDb_DbIWdw MPW;
  193.   int count;
  194.   MPW = XbWVWd_W;
  195.   XbWFWd_GetList();
  196.   XbWVWd_DrawNr = 0;
  197.   for (count = 1;count <= XbWDWd_MaxWdw;count++) {
  198.     if (XbWFWd_GetPara(count, &XbWVWd_W)) {
  199.       if (((*XbWVWd_W.icn) ) == 0) {
  200.         if (XbWFTb_CmpStr((char*)XbWVWd_W.nm,(char*)MPW.nm) != 0) {
  201.           XbWFWd_OvrLap(&XbWVWd_W,&MPW);
  202.           XbWFWd_Hide(&XbWVWd_W,&MPW);
  203.           XbWVWd_LastDsp = XbWVWd_W;
  204.           XbWFWd_Refresh(); XbWFWd_Rebuild();
  205.           };
  206.         };
  207.       };
  208.     };
  209.   if (MPW.nm != NULL) {
  210.     XbWVWd_W = MPW;
  211.     *XbWVWd_W.wov = 0;
  212.     }
  213.   else {
  214.     if (XbWVWd_LastDsp.nm != NULL) {
  215.       XbWVWd_W = XbWVWd_LastDsp;
  216.       *XbWVWd_W.wov = 0;
  217.       };
  218.     };
  219.   };
  220. /*}}}  */
  221. /*{{{  XbWFWd_DrawAll(     ***    Alle Windows zeichnen*/
  222. void  XbWFWd_DrawAll(void){
  223.   XbWDDb_DbIWdw MPW;
  224.   int cmrk,count;
  225.   cmrk = XbWVMs_CSet;
  226.   XbWFGr_CurOFF();
  227.   MPW = XbWVWd_W;
  228.   XbWFWd_DrwASub();
  229.   if (MPW.nm != NULL) {
  230.     XbWVWd_W = MPW;
  231.     }
  232.   else {
  233.     if (XbWVWd_LastDsp.nm != NULL) {
  234.       XbWVWd_W = XbWVWd_LastDsp;
  235.       };
  236.     };
  237.   if (((*XbWVWd_W.icn) ) == 0) {
  238.     for (count = 1;count <= XbWDWd_MaxWdw;count++) {
  239.       if (XbWFWd_GetPara(count, &MPW)) {
  240.         if (((*XbWVWd_W.icn) ) == 0) {
  241.           if (XbWFTb_CmpStr((char*)XbWVWd_W.nm,(char*)MPW.nm) != 0) {
  242.             XbWFWd_OvrLap(&MPW,&XbWVWd_W);
  243.             XbWFWd_Hide(&MPW,&XbWVWd_W);
  244.             };
  245.           };
  246.         };
  247.       };
  248.     XbWFWd_ReDisp();
  249.     };
  250.   if (cmrk) { XbWFGr_CurON(); };
  251.   };
  252. /*}}}  */
  253. /*{{{  XbWFWd_EraWdw(      ***    Ein Window loeschen*/
  254. void  XbWFWd_EraWdw(void){
  255.   if (((*XbWVWd_W.icn) ) == 0) {
  256.     XbWFWd_Erase(&XbWVWd_W);
  257.     };
  258.   };
  259. /*}}}  */
  260. /*{{{  XbWFWd_Rebuild(     ***    Alle Objekte eines Windows zeichnen*/
  261. void  XbWFWd_Rebuild(void){
  262.   int cstat = XbWVMs_CSet;
  263.   XbWFGr_CurOFF();
  264.   if ( XbWVWd_W.nm != NULL) {
  265.     if (((*XbWVWd_W.icn) ) == 0) {
  266.       *XbWVWd_W.layer = XbWVWd_DrawNr;
  267.       *XbWVWd_W.wov = 0;
  268.       XbWVWd_DrawNr++;
  269.       XbWVMf_P[0] = (void  *)0;
  270.       XbWFOb_dpO(&XbWVWd_W,NULL);  /* Alle Objekte zeichnen */
  271.       };
  272.     };
  273.   if (cstat) { XbWFGr_CurON(); };
  274.   };
  275. /*}}}  */
  276. /*{{{  XbWFWd_Activate(    ***    Window anwaehlen*/
  277. void  XbWFWd_Activate(char *nm, int savescreen){
  278.   int count;
  279.   XbWDDb_DbIWdw MPW;
  280.   int cstat = XbWVMs_CSet;
  281.   XbWFGr_CurOFF();
  282.   XbWFWd_GetList();
  283.   for (count = 1;count<= XbWDWd_MaxWdw;count++) {
  284.     if (XbWFTb_CmpStr(nm,XbWVWd_Name[count])==0){
  285.       if (XbWFWd_GetPara(count, &XbWVWd_W)) {
  286.         if (cstat) { XbWFGr_CurON(); };
  287.         return;
  288.         }
  289.       else {
  290.         count = XbWDWd_MaxWdw+10;
  291.         };
  292.       };
  293.     };
  294.   XbWVWd_W=MPW;
  295.   if (cstat) { XbWFGr_CurON(); };
  296.   };
  297. /*}}}  */
  298. /*{{{  XbWFWd_Iconize(     ***    Window iconizen*/
  299. void  XbWFWd_Iconize(void  *(*p)[]){
  300.   char aname[20];
  301.   int cstat = XbWVMs_CSet;
  302.   XbWFGr_CurOFF();
  303.   strcpy(aname,XbWVWd_W.nm);
  304.  
  305.   if ((int)(*p)[0] > 0) {
  306.     XbWFWd_Activate((char*)(*p)[1],0);
  307.     };
  308.   XbWVWd_LastDsp.nm = NULL;
  309.   XbWFWd_EraWdw();
  310.   *XbWVWd_W.icn = 1;
  311.  
  312.   if ((int)(*p)[0] > 0) {
  313.     if (strcmp(aname,XbWVWd_W.nm) != 0){
  314.       XbWFWd_SwitchTo(aname,0);
  315.       XbWFWd_DrawAll();
  316.       XbWFWd_SwitchTo(aname,16);
  317.       }
  318.     else {
  319.       XbWFWd_DrawAll();
  320.       };
  321.     }
  322.   else {
  323.     XbWFWd_DrawAll();
  324.     };
  325.   XbWVWd_W = XbWVWd_LastDsp;
  326.  
  327.   if (cstat) { XbWFGr_CurON(); };
  328.   };
  329. /*}}}  */
  330. /*{{{  XbWFWd_IconAll(     ***    Alle Ede iconizen*/
  331. void  XbWFWd_IconAll(void){
  332.   int count;
  333.   XbWDDb_DbIWdw MPW;
  334.   int cstat = XbWVMs_CSet;
  335.   XbWFGr_CurOFF();
  336.   MPW = XbWVWd_W;
  337.   XbWFWd_GetList();
  338.   for (count = 1;count<= XbWDWd_MaxWdw;count++) {
  339.     if (XbWFWd_GetPara(count, &XbWVWd_W)) {
  340.       XbWVWd_LastDsp = XbWVWd_W;
  341.       *XbWVWd_W.icn = 1;
  342.       };
  343.     };
  344.   if (MPW.nm != NULL) {
  345.     XbWVWd_W = MPW;
  346.     }
  347.   else {
  348.     if (XbWVWd_LastDsp.nm != NULL) {
  349.       XbWVWd_W = XbWVWd_LastDsp;
  350.       };
  351.     };
  352.   XbWFWd_BackGr();
  353.   XbWFWd_DrawAll();
  354.   if (cstat) { XbWFGr_CurON(); };
  355.   };
  356. /*}}}  */
  357. /*{{{  XbWFWd_SwitchTo(    ***    Window anwaehlen*/
  358. void  XbWFWd_SwitchTo(char *nm, int savescreen){
  359.   int count,mi;
  360.   XbWDDb_DbIWdw MPW;
  361.   int redraw = 0;
  362.   int cstat = XbWVMs_CSet;
  363.   XbWFGr_CurOFF();
  364.   XbWFWd_GetList();
  365.   for (count = 1;count<= XbWDWd_MaxWdw;count++) {
  366.     if (XbWFTb_CmpStr(nm,XbWVWd_Name[count])==0){
  367.       if (XbWFWd_GetPara(count, &XbWVWd_W)) {
  368.         mi = count;
  369.         if (XbWVWd_RedrawON){
  370.           if ((*XbWVWd_W.wov)) {
  371.             redraw = 1;
  372.             };
  373.           };
  374.         if ( (*XbWVWd_W.tp != 2 ) &
  375.            (((*XbWVWd_W.icn) ) == 1) ) {
  376.           if (savescreen & 0x10) {
  377.             redraw = 1;
  378.             };
  379.           };
  380.         for (count = 1;count<= XbWDWd_MaxWdw;count++) {
  381.           if (XbWFWd_GetPara(count, &MPW)) {
  382.             if (XbWFWd_OvrLap(&MPW,&XbWVWd_W)){
  383.               if ( (!(savescreen & 0x20)) & (XbWVWd_AClos)) {
  384.                 *MPW.icn = 1;
  385.                 };
  386.               };
  387.             XbWFWd_Hide(&MPW,&XbWVWd_W);
  388.             }
  389.           else {
  390.             count = XbWDWd_MaxWdw + 10;
  391.             };
  392.           };
  393.         XbWFWd_GetPara(mi,&XbWVWd_W);
  394.         if ( (*XbWVWd_W.tp != 2 ) &
  395.            (((*XbWVWd_W.icn) ) == 1) ) {
  396.           *XbWVWd_W.icn = 0;
  397.           };
  398.         if (savescreen & 1){
  399.           XbWFWd_SaveImage(&XbWVWd_W);
  400.           };
  401.         if (redraw) {
  402.           XbWFWd_Draw();
  403.           XbWFWd_Rebuild();
  404.           };
  405.         if (cstat) { XbWFGr_CurON(); };
  406.         return;
  407.         }
  408.       else {
  409.         count = XbWDWd_MaxWdw+10;
  410.         };
  411.       };
  412.     };
  413.   if (cstat) { XbWFGr_CurON(); };
  414.   };
  415. /*}}}  */
  416. /*{{{  XbWFWd_Select(      ***    Ruft SwitchTo auf*/
  417. int  XbWFWd_Select(void  *(*p)[]){
  418.   if ((int)(*p)[0] > 0) {
  419.     if ((int)(*p)[0] > 1) {
  420.       XbWFWd_SwitchTo((char*)(*p)[1],(int)(*p)[2]);
  421.       }
  422.     else {
  423.       XbWFWd_SwitchTo((char*)(*p)[1], 16 );
  424.       };
  425.     return(0);
  426.     };
  427.   return(1);
  428.   };
  429. /*}}}  */
  430. /*{{{  XbWFWd_DrawP(       ***    Neuzeichnen*/
  431. void  XbWFWd_DrawP(void){
  432.   XbWFWd_Draw();
  433.   XbWFWd_Rebuild();
  434.   };
  435. /*}}}  */
  436. /*{{{  XbWFWd_Draw(        ***    Neuzeichnen (???)*/
  437. void  XbWFWd_Draw(void){
  438.   XbWFWd_Refresh();
  439.   if (((*XbWVWd_W.icn) ) == 0) {
  440.     XbWVWd_LastDsp = XbWVWd_W;
  441.     };
  442.   };
  443. /*}}}  */
  444. /*{{{  XbWFWd_Exists(      ***    Ob Window existiert*/
  445. int  XbWFWd_Exists(char *refname){
  446.   int count;
  447.   XbWDDb_DbIWdw MPW;
  448.   XbWFWd_GetList();
  449.   for (count = 1;count <= XbWDWd_MaxWdw;count++) {
  450.     if (XbWFWd_GetPara(count,&MPW) != 0) {
  451.       if (XbWFTb_CmpStr((char*)MPW.nm,refname)==0){
  452.         return(count);
  453.         };
  454.       };
  455.     };
  456.   return(-1);
  457.   };
  458. /*}}}  */
  459. /*{{{  XbWFWd_SetPort(     ***    Videoport auf Window einstellen*/
  460. void  XbWFWd_SetPort(void  *(*p)[]){
  461.   if ( (int)(*p)[0] > 0) {
  462.     XbWFWd_Select(p);
  463.     };
  464.   XbWFGr_MinPort(
  465.     *XbWVWd_W.nx+1,
  466.     *XbWVWd_W.ny+1,
  467.     *XbWVWd_W.nx+*XbWVWd_W.sx-1,
  468.     *XbWVWd_W.ny+*XbWVWd_W.sy);
  469.   };
  470. /*}}}  */
  471. /*{{{  XbWFWd_NotInWdw(    ***    Check ob Maus ausserhalb*/
  472. int  XbWFWd_NotInWdw(void){
  473.   if ((XbWVWd_W.nm != NULL) & (XbWVMs_CX >= *XbWVWd_W.nx) &
  474.       (XbWVMs_CY >= *XbWVWd_W.ny) &
  475.       (XbWVMs_CX <= *XbWVWd_W.nx + *XbWVWd_W.sx) &
  476.       (XbWVMs_CY <= *XbWVWd_W.ny + *XbWVWd_W.sy)) {
  477.     return(0);
  478.     }
  479.   else {
  480.     return(1);
  481.     };
  482.   };
  483. /*}}}  */
  484. /*{{{  XbWFWd_InInner(     ***    ...innerhalb*/
  485. int  XbWFWd_InInner(void){
  486.   if (((*XbWVWd_W.icn) ) == 0) {
  487.     if ((XbWVWd_W.nm != NULL) &
  488.         (XbWVMs_CX >= *XbWVWd_W.nx) &
  489.         (XbWVMs_CY >= *XbWVWd_W.ny) &
  490.         (XbWVMs_CX <= *XbWVWd_W.nx + *XbWVWd_W.sx ) &
  491.         (XbWVMs_CY <= *XbWVWd_W.ny + *XbWVWd_W.sy )){
  492.       return(1);
  493.       };
  494.     };
  495.   return(0);
  496.   };
  497. /*}}}  */
  498. /*{{{  XbWFWd_SlctOther(   ***    ...auf einem anderem Window*/
  499. void  XbWFWd_SlctOther(void){
  500.   int ccount,count;
  501.   XbWDDb_DbIWdw MPW;
  502.   int lt[XbWDWd_MaxWdw+2];
  503.   int ln[XbWDWd_MaxWdw+2];
  504.   int echtfnd = 0;
  505.   MPW = XbWVWd_W;
  506.   ccount = 1;
  507.   XbWFWd_GetList();
  508.   ccount = 1;
  509.   if (XbWVWd_FoundNo < 1) {
  510.     return;
  511.     };
  512.   if (!XbWVWd_AClos) {
  513.     for (ccount = 1; ccount <= XbWVWd_FoundNo; ccount++){
  514.       lt[ccount] = -1;
  515.       };
  516.     echtfnd = 0;
  517.     for (ccount = 1; ccount <= XbWVWd_FoundNo; ccount++){
  518.       if (XbWFWd_GetPara(ccount, &XbWVWd_W) != 0) {
  519.         lt[echtfnd] = *XbWVWd_W.layer;
  520.         ln[echtfnd] = ccount;
  521.         echtfnd++;
  522.         };
  523.       };
  524.     echtfnd--;
  525.     if (echtfnd < 0) {return; };
  526.     if (echtfnd > 0) {
  527.       int tausch = 1;
  528.       while (tausch) {
  529.         tausch = 0;
  530.         for (ccount = 0; ccount < echtfnd; ccount++){
  531.           for (count = ccount+1; count <= echtfnd; count++){
  532.             if (lt[count] > lt[ccount]) {
  533.               { int a,b;
  534.                 a = lt[ccount];
  535.                 b = ln[ccount];
  536.                 lt[ccount] = lt[count];
  537.                 ln[ccount] = ln[count];
  538.                 lt[count] = a;
  539.                 ln[count] = b;
  540.                 tausch = 1;
  541.                 };
  542.               };
  543.             };
  544.           };
  545.         };
  546.       };
  547.     }
  548.   else {
  549.     echtfnd = XbWVWd_FoundNo;
  550.     for (ccount = 0; ccount < echtfnd; ccount++) {
  551.       ln[ccount] = ccount+1;
  552.       };
  553.     };
  554.   ccount = 0;
  555.   while (ccount <= echtfnd)  {
  556.     if (XbWFWd_GetPara(ln[ccount], &XbWVWd_W) != 0) {
  557.       if (((*XbWVWd_W.icn) ) == 0) {
  558.         if ((XbWVMs_CX>= *XbWVWd_W.nx) &&(XbWVMs_CY>= *XbWVWd_W.ny) &&
  559.             (XbWVMs_CX<= *XbWVWd_W.nx+ *XbWVWd_W.sx)&&
  560.             (XbWVMs_CY<= *XbWVWd_W.ny + *XbWVWd_W.sy)) {
  561.           int mrk;
  562.           mrk = *XbWVWd_W.wov;
  563.           for (count = 1;count< XbWDWd_MaxWdw;count++) {
  564.             if (XbWFWd_GetPara(count, &MPW)) {
  565.               if (XbWFWd_OvrLap(&MPW,&XbWVWd_W)){
  566.                 *MPW.icn = 1;
  567.                 };
  568.               XbWFWd_Hide(&MPW,&XbWVWd_W);
  569.               }
  570.             else {
  571.               count = XbWDWd_MaxWdw + 10;
  572.               };
  573.             };
  574.           XbWFWd_GetPara(ln[ccount],&XbWVWd_W);
  575.           *XbWVWd_W.icn = 0;
  576.           if (mrk){
  577.             if (XbWVWd_RedrawON){
  578.               XbWFWd_Draw();
  579.               XbWFWd_Rebuild();
  580.               };
  581.             };
  582.           return;
  583.       };};};
  584.     ccount++;
  585.     };
  586.   XbWVWd_W = MPW;
  587.   };
  588. /*}}}  */
  589. /*{{{  XbWFWd_LockON(      ***    Schutz vor falschen Verlassen EIN*/
  590. void  XbWFWd_LockON(void){
  591.   *XbWVWd_W.wfx = 1;
  592.   XbWSMs_Warp(*XbWVWd_W.nx+(*XbWVWd_W.sx)/2,*XbWVWd_W.ny+(*XbWVWd_W.sy)/2);
  593.   };
  594. /*}}}  */
  595. /*{{{  XbWFWd_LockEdit(    ***    Schutz EIN wenn Objekt angeklickt*/
  596. void  XbWFWd_LockEdit(void){
  597.   *XbWVWd_W.wfe = 1;
  598.   XbWSMs_Warp(*XbWVWd_W.nx+(*XbWVWd_W.sx)/2,*XbWVWd_W.ny+(*XbWVWd_W.sy)/2);
  599.   };
  600. /*}}}  */
  601. /*{{{  XbWFWd_LockOFF(     ***    Schutz AUS*/
  602. void  XbWFWd_LockOFF(void){
  603.   *XbWVWd_W.wfx = 0;
  604.   *XbWVWd_W.wfe = 0;
  605.   };
  606. /*}}}  */
  607. /*{{{  XbWFWd_ChkDisp(     ***    Check ob Hintergrund-Display von Wdws noetig*/
  608. void  XbWFWd_ChkDisp(void){
  609.   XbWDDb_DbIWdw MPW;
  610.   time_t ntime;
  611.   char anam[20];
  612.   if (XbWVWd_Time > 0) {
  613.     ntime = XbWVSy_Time;
  614.     if (ntime <= XbWVWd_Time+3) { return; };
  615.     XbWVWd_Time = 0;
  616.     };
  617.   strcpy(anam,(char*)XbWVWd_W.nm);
  618.   XbWFWd_GetList();
  619.   if (XbWVWd_ADspNr > XbWVWd_MaxReg) {
  620.     XbWVWd_Time = XbWVSy_Time;
  621.     XbWVWd_ADspNr = 0;
  622.     };
  623.   if (XbWFWd_GetPara(XbWVWd_ADspNr, &MPW) == 0) {
  624.     }
  625.   else {
  626.     *XbWVWd_W.wov = 0;
  627.     if (strcmp(anam,(char*)MPW.nm) != 0) {
  628.       int draw_wdw_border = 0;
  629.       draw_wdw_border = (*MPW.bd) & 0x10;
  630.       switch ((*MPW.bd)&0x0F) {
  631.         case 3:
  632.                   XbWFGr_CurOFF();
  633.                   if ((*MPW.icn == 1) | (*MPW.wov != 0)){
  634.                     XbWFWd_SwitchTo((char*)MPW.nm,16);
  635.                     }
  636.                   else {
  637.                     XbWFWd_SwitchTo((char*)MPW.nm,0);
  638.                     if (draw_wdw_border) {
  639.                       XbWFWd_Draw();
  640.                       };
  641.                     XbWFWd_Rebuild();
  642.                     };
  643.                   XbWFGr_CurON();
  644.                   break;
  645.         case 2: if (*MPW.icn == 0) {
  646.                   XbWFGr_CurOFF();
  647.                   if ((*MPW.icn == 1) | (*MPW.wov != 0)){
  648.                     XbWFWd_SwitchTo((char*)MPW.nm,16);
  649.                     }
  650.                   else {
  651.                     XbWFWd_SwitchTo((char*)MPW.nm,0);
  652.                     if (draw_wdw_border) {
  653.                       XbWFWd_Draw();
  654.                       };
  655.                     XbWFWd_Rebuild();
  656.                     };
  657.                   XbWFGr_CurON();
  658.                   };
  659.                 break;
  660.         case 1: if ((*MPW.icn == 0) & (*MPW.wov == 0)) {
  661.                   XbWFGr_CurOFF();
  662.                   XbWFWd_SwitchTo((char*)MPW.nm,0);
  663.                   XbWFWd_Rebuild();
  664.                   XbWFGr_CurON();
  665.                   };
  666.                 break;
  667.         };
  668.       };
  669.     };
  670.   XbWVWd_ADspNr++;
  671.   };
  672. /*}}}  */
  673. /*{{{  XbWFWd_ChkAct(      ***    Check auf Hintergrund-Aktion von Objekten*/
  674. void  XbWFWd_ChkAct(void){
  675.   time_t ntime;
  676.   char sstr[40];
  677.   int ii;
  678.   int suchnummer=0;
  679.   XbWDDb_DbIVar  *sv_gp;
  680.  
  681.   ntime = XbWVSy_Time;
  682.   if (ntime == XbWVSy_AltChkActTime){ return;};
  683.   XbWVSy_AltChkActTime = ntime;
  684.   if ((ntime & 0x0003) != 0){ return; };
  685.  
  686.   if  ((suchnummer=(ntime & 0x1FFF))==0x1000) {goto start_edit;};
  687.   if  ((suchnummer=(ntime & 0x0FFF))==0x0800) {goto start_edit;};
  688.   if  ((suchnummer=(ntime & 0x07FF))==0x0400) {goto start_edit;};
  689.   if  ((suchnummer=(ntime & 0x03FF))==0x0200) {goto start_edit;};
  690.   if  ((suchnummer=(ntime & 0x01FF))==0x0100) {goto start_edit;};
  691.   if  ((suchnummer=(ntime & 0x00FF))==0x0080) {goto start_edit;};
  692.   if  ((suchnummer=(ntime & 0x007F))==0x0040) {goto start_edit;};
  693.   if  ((suchnummer=(ntime & 0x003F))==0x0020) {goto start_edit;};
  694.   if  ((suchnummer=(ntime & 0x001F))==0x0010) {goto start_edit;};
  695.   if  ((suchnummer=(ntime & 0x000F))==0x0008) {goto start_edit;};
  696.   if  ((suchnummer=(ntime & 0x0007))==0x0004) {goto start_edit;};
  697.   if  ((suchnummer=(ntime & 0x0003))==0x0000) {suchnummer = 2; goto start_edit;};
  698.   return;
  699.   start_edit:;
  700.  
  701.   sprintf(sstr,"ed_obj%d",suchnummer);
  702.   sv_gp = XbWFDb_FindGrp("SVR",sstr);
  703.   if (sv_gp != NULL){
  704.     char *obj_nam;
  705.     ii=0;
  706.     sprintf(sstr,"o%d",ii);
  707.     while ((obj_nam = (char*)XbWFDb_VarInh(sv_gp,XbWDDb_Str,sstr,1)) != NULL){
  708.       sv_gp = XbWFDb_FindGrp("OBJ",obj_nam);
  709.       if (sv_gp != NULL){
  710.         char *wdwname;
  711.         wdwname = (char*)XbWFDb_VarInh(sv_gp,XbWDDb_Str,"W",1);
  712.         XbWFWd_SwitchTo(wdwname,48);
  713.         XbWFOb_EditAndDisp(obj_nam,1);
  714.         };
  715.       ii++;
  716.       sprintf(sstr,"o%d",ii);
  717.       };
  718.     };
  719.   };
  720. /*}}}  */
  721. /*{{{  XbWFWd_OManager(    ***    Hauptroutine bei PopUpWindow*/
  722. void  XbWFWd_OManager(int popup, char *wname){
  723.   unsigned char tastencode1,tastencode2;
  724.   char teststr[160],*pptr;
  725.   int warn_state = 0;
  726.   XbWDDb_DbIVar  *grp_ptr;
  727.   int strmode = 0;
  728.   XbWDDb_DbIWdw MPW;
  729.   XbWFGr_CurOFF();
  730.   XbWSMs_Warp(10,10);
  731.  
  732.   if (popup){
  733.     XbWFWd_SwitchTo(wname,1);
  734.     XbWFWd_Draw();
  735.     XbWFWd_Rebuild();
  736.     *XbWVWd_W.wfx = 1;
  737.     };
  738.   XbWFGr_CurON();
  739.   MPW = XbWVWd_W;
  740.   XbWSMs_SetArrowCursor();
  741.   while(XbWVWd_Activ){
  742.     XbWPSy_SystemManagerHook(&XbWVWd_W);
  743. #ifdef XbW_SYSDEF_X11_VERSION
  744.     { XEvent event;
  745.       long lastexpose=0,neuexpose;
  746.       for ( ; ; ) {
  747.         XbWVMs_LButt = 0;
  748.         XbWVMs_RButt = 0;
  749.         XbWVMs_MButt = 0;
  750.         XbWVMs_Button = 0;
  751.         XNextEvent(XbWVSy_ConTxt.dpy, &event);
  752.         XbWVSy_Time = XbWSSy_TimeSec();
  753.         if (! *XbWVWd_W.wfx ) {
  754.           XbWFWd_ChkAct();
  755.           XbWFWd_ChkDisp();
  756.           };
  757.         switch(event.type){
  758.           case Expose:
  759.             if (lastexpose < (neuexpose=XbWSSy_TimeSec()) ){
  760.               lastexpose=neuexpose;
  761.               XbWFWd_BackGr();
  762.               XbWFWd_DrawAll();
  763.               };
  764.             break;
  765.           case EnterNotify:
  766.           case MotionNotify:
  767.             goto XbW_OManagerWeiter;
  768.             break;
  769.           case KeyPress:
  770.             {
  771.               KeySym keysym;
  772.               int n;
  773.               char string[257];
  774.               XKeyEvent *keyevent;
  775.               keyevent = (XKeyEvent *)&event;
  776.               string[0]=0;
  777.               n = XLookupString(keyevent, string, 256, &keysym, NULL);
  778.               strncpy(XbWVSy_ConTxt.key,string,255);
  779.               XbWVSy_ConTxt.key[255] = 0;
  780.               XbWVSy_ConTxt.keysym = keysym;
  781.               XbWVSy_ConTxt.is_a_key_waiting = 1;
  782.               goto XbW_OManagerWeiter;
  783.               };
  784.           case ButtonPress:
  785.             { int rootx,rooty,winx,winy,mask;
  786.               Window root, child;
  787.               if ( XQueryPointer(
  788.                      XbWVSy_ConTxt.dpy,
  789.                      XbWVSy_ConTxt.window,
  790.                      &root, &child,
  791.                      &rootx, &rooty,
  792.                      &winx, &winy,
  793.                      &mask
  794.                      )
  795.                    ){
  796.                 XbWVMs_Button = 0;
  797.                 XbWVMs_LButt = 0;
  798.                 XbWVMs_MButt = 0;
  799.                 XbWVMs_RButt = 0;
  800.                 if (mask & Button1Mask){
  801.                   XbWVMs_LButt = 1;
  802.                   XbWVMs_Button = 1;
  803.                   };
  804.                 if (mask & Button2Mask){
  805.                   XbWVMs_MButt = 1;
  806.                   XbWVMs_Button = 1;
  807.                   };
  808.                 if (mask & Button3Mask){
  809.                   XbWVMs_RButt = 1;
  810.                   XbWVMs_Button = 1;
  811.                   };
  812.                 XbWVMs_XPos = winx;
  813.                 XbWVMs_YPos = winy;
  814.                 goto XbW_OManagerWeiter;
  815.                 };
  816.               };
  817.             break;
  818.  
  819.           };
  820.         };
  821.       };
  822.     XbW_OManagerWeiter:;
  823. #endif
  824.  
  825.     if ( *XbWVWd_W.wfx ) {
  826.       if (!XbWFTb_InBox(XbWVMs_XPos,XbWVMs_YPos,
  827.           *XbWVWd_W.nx,*XbWVWd_W.ny,
  828.           *XbWVWd_W.nx+*XbWVWd_W.sx,*XbWVWd_W.ny+*XbWVWd_W.sy)) {
  829.         /* XbWSMs_SetStopCursor();*/
  830.         if (warn_state != 1){
  831.           XbWFTb_Warning("Please quit the active window explicitly!");
  832.           warn_state = 1;
  833.           };
  834.         }
  835.       else  {
  836.         XbWSMs_SetArrowCursor();
  837.         if (warn_state != 2){
  838.           XbWFTb_Message("XbW - Multiwindow Dialogmanager.");
  839.           warn_state = 2;
  840.           };
  841.         };
  842.       }
  843.     else {
  844.       if (XbWVMs_PtrActualPtr != XbWVMs_PtrPtrArrow){
  845.         XbWSMs_SetArrowCursor();
  846.         };
  847.       };
  848.  
  849.     if (popup) {
  850.       if (! *XbWVWd_W.wfx ) {
  851.         XbWFGr_CurOFF();
  852.         XbWFWd_RestImage(&XbWVWd_W);
  853.         if (MPW.nm != NULL){
  854.           XbWFWd_SwitchTo((char*)MPW.nm,0);
  855.           };
  856.         XbWFGr_CurON();
  857.         return;
  858.         };
  859.       };
  860.     if (XbWVSy_ConTxt.is_a_key_waiting){
  861.       while (!XbWSMs_IsAKey(1)){;};
  862.       XbWSMs_GetKey(&tastencode2,&tastencode1);
  863.  
  864.       strmode = 0;
  865.       if (XbWFWd_NotInWdw()==1)   {
  866.         XbWFGr_CurOFF();
  867.         XbWFWd_SlctOther();
  868.         XbWVEd_nxt = Vor;
  869.         };
  870.       if ((!tastencode1)&(tastencode2 == 82)){
  871.         if (XbWVEd_ins == 1) { XbWVEd_ins = 0;}  /* INSERT */
  872.         else {XbWVEd_ins = 1;};
  873.         XbWFEd_OutIns();
  874.         };
  875.  
  876.       if ( ((tastencode1 >= 'a') & (tastencode1 <= 'z')) ||
  877.            ((tastencode1 >= 'A') & (tastencode1 <= 'Z')) ||
  878.            ((tastencode1 >= '0') & (tastencode1 <= '9')) ||
  879.             (tastencode1 == '\\') | (tastencode1 == '@') ||
  880.             (tastencode1 == '?') ||
  881.             (tastencode1 == ' ')                          ) {
  882.         XbWFGr_CurOFF();
  883.         if (tastencode1 != ' ') {
  884.           if (XbWVWd_CStr[0] == 0) {
  885.             XbWVWd_CStr[1] = 0;
  886.             };
  887.           XbWVWd_CStr[0] = (char)tastencode1;
  888.           XbWFEd_GetSStr("Command:",XbWVWd_CStr,98,1);
  889.           }
  890.         else {
  891.           XbWVWd_CStr[0] = 0;
  892.           XbWFEd_GetSStr("Command:",XbWVWd_CStr,98,1);
  893.           };
  894.         XbWVWd_CErr = 0;
  895.         strcpy(XbWVWd_CStr,(char*)XbWFTb_PckTxt(XbWVWd_CStr));
  896.         strmode = 1;
  897.         sprintf(teststr,"Executing %s...",XbWVWd_CStr);
  898.         XbWFTb_Message(teststr);
  899.         XbWFMf_ReadMakro(XbWVWd_CStr);
  900.         goto makro_beendet;
  901.         }
  902.       else {
  903.         sprintf(teststr,"%s:%d.%d",(char*)XbWVWd_W.nm,tastencode1,tastencode2);
  904.         };
  905.       XbWFGr_CurOFF();
  906.       if ((grp_ptr = XbWFDb_FindGrp("KEY",teststr)) != NULL) {
  907.         if ((pptr = (char*)XbWFDb_VarInh(grp_ptr,XbWDDb_Str,"T",1)) != NULL) {
  908.           XbWFMf_ReadMF(pptr);
  909.           };
  910.         if ((pptr = (char*)XbWFDb_VarInh(grp_ptr,XbWDDb_Str,"K",1)) != NULL) {
  911.           XbWFMf_ReadMakro(pptr);
  912.           };
  913.         if ((pptr = (char*)XbWFDb_VarInh(grp_ptr,XbWDDb_Str,"O",1)) != NULL) {
  914.           XbWFOb_EditAndDisp(pptr,1);
  915.           };
  916.         if ((pptr = (char*)XbWFDb_VarInh(grp_ptr,XbWDDb_Str,"W",1)) != NULL) {
  917.           XbWFWd_SwitchTo(pptr,16);
  918.           };
  919.         }
  920.       else {
  921.         if (!strmode) {
  922.           sprintf(teststr,"@XW:%d.%d",tastencode1,tastencode2);
  923.           }
  924.         else {
  925.           sprintf(teststr,"@XW:%s",XbWVWd_CStr);
  926.           };
  927.         if ((grp_ptr = XbWFDb_FindGrp("KEY",teststr)) != NULL) {
  928.           if ((pptr = (char*)XbWFDb_VarInh(grp_ptr,XbWDDb_Str,"T",1)) != NULL) {
  929.             XbWFMf_ReadMF(pptr);
  930.             };
  931.           if ((pptr = (char*)XbWFDb_VarInh(grp_ptr,XbWDDb_Str,"K",1)) != NULL) {
  932.             XbWFMf_ReadMakro(pptr);
  933.             };
  934.           if ((pptr = (char*)XbWFDb_VarInh(grp_ptr,XbWDDb_Str,"O",1)) != NULL) {
  935.             XbWFOb_EditAndDisp(pptr,1);
  936.             };
  937.           if ((pptr = (char*)XbWFDb_VarInh(grp_ptr,XbWDDb_Str,"W",1)) != NULL) {
  938.             XbWFWd_SwitchTo(pptr,16);
  939.             };
  940.           }
  941.         else {
  942.           if (tastencode1 == 0){
  943.             switch (tastencode2){
  944.               case 83:                       /* DEL */
  945.                        XbWFGr_CurOFF();
  946.                        if (((*XbWVWd_W.icn) ) == 0) {
  947.                          XbWFOb_MovToPos(&XbWVWd_W,XbWVMs_CX,XbWVMs_CY);
  948.                          XbWSMs_WButtUp(); XbWFGr_CurON();
  949.                          };
  950.               case 113:XbWSMs_DrReset(); break; /* Alt-F10 */
  951.  
  952.               default: XbWFTb_HBeep();
  953.                        break;
  954.               };
  955.             }
  956.           else {
  957.             if (strmode) {
  958.               sprintf(teststr,"!? %s ?! Sorry.",XbWVWd_CStr);
  959.               XbWFTb_Message(teststr);
  960.               XbWFTb_HBeep();
  961.               XbWVWd_CErr = 1;
  962.               };
  963.             };
  964.           };
  965.         };
  966.       };
  967.     makro_beendet:;
  968.     XbWVSy_Time = XbWSSy_TimeSec();
  969.     if (! *XbWVWd_W.wfx ) {
  970.       XbWFWd_ChkAct();
  971.       XbWFWd_ChkDisp();
  972.       };
  973.     if (XbWVMs_Bewegt==1)   {
  974.       XbWFGr_CurOFF();
  975.       XbWVMs_CX = XbWVMs_XPos; XbWVMs_CY = XbWVMs_YPos;
  976.       };
  977.     XbWFGr_CurON();
  978.     if (XbWVMs_Button==1)   {
  979.       if (XbWVMs_LButt==1)   {
  980.         XbWVMs_CX = XbWVMs_XPos; XbWVMs_CY = XbWVMs_YPos;
  981.         if (((*XbWVWd_W.icn) ) == 0) {
  982.           if (XbWFWd_InInner()==1){
  983.             XbWFGr_CurOFF();
  984.             XbWVEd_nxt = Vor;
  985.             XbWFOb_EdObjMausPos(&XbWVWd_W,XbWVMs_CX,XbWVMs_CY);
  986.             goto stp2;
  987.             };
  988.           };
  989.         if (XbWFWd_NotInWdw()==1)   {
  990.           if ((!popup)&&(!(*XbWVWd_W.wfx))) {
  991.             XbWFGr_CurOFF();
  992.             XbWFWd_SlctOther();
  993.             XbWVEd_nxt = Vor;
  994.             if (XbWFWd_InInner()==1){
  995.               XbWFOb_EdObjMausPos(&XbWVWd_W,XbWVMs_CX,XbWVMs_CY);
  996.               };
  997.             goto stp2;
  998.             }
  999.           else {
  1000.             XbWFTb_HBeep();
  1001.             goto stp2;
  1002.             };
  1003.           };
  1004.         };
  1005.       if (XbWVMs_RButt==1)   {
  1006.         XbWVMs_CX = XbWVMs_XPos; XbWVMs_CY = XbWVMs_YPos;
  1007.         if ((!popup)&(!(*XbWVWd_W.wfx))) {
  1008.           XbWFGr_CurOFF();
  1009.           if (XbWFWd_NotInWdw()==1)   {
  1010.             XbWFWd_SlctOther();
  1011.             };
  1012.           XbWVEd_nxt = Vor;
  1013.           if (XbWFWd_InInner()==1){
  1014.             XbWFOb_GiveInfo(&XbWVWd_W,XbWVMs_CX,XbWVMs_CY,0);
  1015.             goto stp2;
  1016.             };
  1017.           };
  1018.         goto stp2;
  1019.         };
  1020.       if (XbWVMs_MButt==1)   {
  1021.         XbWVMs_CX = XbWVMs_XPos; XbWVMs_CY = XbWVMs_YPos;
  1022.         XbWFGr_CurOFF();
  1023.         if ((!popup)&(!(*XbWVWd_W.wfx))) {
  1024.           if (XbWFWd_NotInWdw()==1)   {
  1025.             XbWFWd_SlctOther();
  1026.             };
  1027.           XbWVEd_nxt = Vor;
  1028.           };
  1029.         if (XbWFWd_InInner()==1){
  1030.           XbWFOb_MovToPos(&XbWVWd_W,XbWVMs_CX,XbWVMs_CY);
  1031.           XbWSMs_WButtUp(); XbWFGr_CurON();
  1032.           };
  1033.         };
  1034.       stp2:;
  1035.       XbWFGr_CurON();
  1036.       };
  1037.     };
  1038.   };
  1039. /*}}}  */
  1040. /*{{{  XbWFWd_WManager(    ***    Hauptroutine zur Fensterverwaltung*/
  1041. void  XbWFWd_WManager(void){
  1042.   XbWFWd_OManager(0," ");
  1043.   };
  1044. /*}}}  */
  1045.  
  1046. /*{{{  XbWFWd_PopUp(       ***    (PopUpWindow)*/
  1047. void  XbWFWd_PopUp(void  *(*p)[]){
  1048.   if ((int)(*p)[0] > 0) {
  1049.     XbWFWd_OManager(1,(char*)(*p)[1]);
  1050.     };
  1051.   };
  1052. /*}}}  */
  1053. /*{{{  XbWFWd_SaveRestore( ****/
  1054. void  XbWFWd_SaveRestore(XbWDDb_DbIWdw  *WI, int read){
  1055.   FILE *fp;
  1056.   XbWDGr_VidFram *vf;
  1057.   int ii;
  1058.   char fname[80]; int vh;
  1059.   sprintf(fname,"\\xw\\scratch\\%s.buf",WI->nm);
  1060.   if (read) {
  1061.     fp = XbWSSy_fopen(fname,"rb");
  1062.     }
  1063.   else {
  1064.     fp = XbWSSy_fopen(fname,"wb");
  1065.     };
  1066.   if (fp != NULL){
  1067.     vf = (XbWDGr_VidFram*)XbWSSy_AlocMem(1,sizeof(XbWDGr_VidFram));
  1068.     if (vf != NULL){
  1069.       if (read){
  1070.         fread(vf,1,20,fp);
  1071.         vh = vf->dy;
  1072.         fseek(fp,0,SEEK_SET);
  1073.         }
  1074.       else {
  1075.         for (ii = 4;ii < 100; ii+=4){
  1076.           vh = ii;
  1077.           if ((long)XbWSGr_GtImSiz(*WI->nx-2,0,*WI->nx+ *WI->sx+4,vh+2) > 65000l){
  1078.             ii = 300; vh-=4;
  1079.             };
  1080.           };
  1081.         vf->dy = vh;
  1082.         };
  1083.  
  1084.       XbWFGr_MaxPort();
  1085.       for (ii=0;vh*(ii-1)< *WI->sy +2;ii++){
  1086.         if (!read){
  1087.           XbWSGr_GetImag(  *WI->nx-2,*WI->ny +vh*ii-2,
  1088.                      *WI->nx+*WI->sx+2,*WI->ny +vh*ii-2+vh,vf->buf);
  1089.           fwrite(vf,(sizeof(XbWDGr_VidFram)/1000)+1,1000,fp);
  1090.           }
  1091.         else {
  1092.           if (fread(vf,(sizeof(XbWDGr_VidFram)/1000)+1,1000,fp) == 1){
  1093.             XbWSGr_PutImag(*WI->nx-2,*WI->ny +vh*ii-2,vf->buf,COPY_PUT);
  1094.             };
  1095.           };
  1096.         };
  1097.       fclose(fp);
  1098.       XbWFGr_ResPort();
  1099.       XbWSSy_FreeMem(vf);
  1100.       };
  1101.     };
  1102.   };
  1103. /*}}}  */
  1104. /*{{{  XbWFWd_SaveImage(   ****/
  1105. void  XbWFWd_SaveImage(XbWDDb_DbIWdw  *WI){
  1106.   XbWFWd_SaveRestore(WI,0);
  1107.   };
  1108. /*}}}  */
  1109. /*{{{  XbWFWd_RestImage(   ****/
  1110. void  XbWFWd_RestImage(XbWDDb_DbIWdw  *WI){
  1111.   XbWFWd_SaveRestore(WI,1);
  1112.   };
  1113. /*}}}  */
  1114.  
  1115. /*{{{  XbWFEd_MaxPort(     ***    ViewPort-Routine fuer Texteditor*/
  1116. void  XbWFEd_MaxPort(void){
  1117.   if (XbWVEd_mvport) {
  1118.     XbWFGr_SetPort();
  1119.     }
  1120.   else {
  1121.     XbWFGr_MaxPort();
  1122.     };
  1123.   };
  1124. /*}}}  */
  1125. /*{{{  XbWFEd_MinPort(     ***    dito*/
  1126. void  XbWFEd_MinPort(void){
  1127.   if (XbWVEd_mvport) {
  1128.     XbWFGr_SetPort();
  1129.     }
  1130.   else {
  1131.     XbWFGr_PopPort();
  1132.     XbWFGr_ResPort();
  1133.     XbWFGr_PushPort();
  1134.     };
  1135.   };
  1136. /*}}}  */
  1137. /*{{{  XbWFEd_OutIns(      ***    Zustand der Insert-Lampe*/
  1138. void  XbWFEd_OutIns(void){
  1139.    XbWFGr_SetPort();
  1140.    if (XbWVEd_ins == 1)   {
  1141.      XbWSGr_TLBox(
  1142.        XbWSGr_GtPhysX()-135,XbWSGr_GtPhysY()-XbWDWd_BordH,XbWSGr_GtPhysX()-78,XbWSGr_GtPhysY()-1,
  1143.        "Insert",XbWVGr_Red,XbWVGr_White,XbWVGr_LRed);
  1144.      }
  1145.    else {
  1146.      XbWSGr_TLBox(
  1147.        XbWSGr_GtPhysX()-135,XbWSGr_GtPhysY()-XbWDWd_BordH,XbWSGr_GtPhysX()-78,XbWSGr_GtPhysY()-1,
  1148.        "Overwr.",XbWVGr_White,XbWVGr_Blue,XbWVGr_White);
  1149.      };
  1150.    XbWFEd_MaxPort();
  1151.    };
  1152. /*}}}  */
  1153. /*{{{  XbWFEd_TextXY(      ***    TextXY fuer Texteditor*/
  1154. void  XbWFEd_TextXY(int x,int y, int cur, char msg[255], unsigned char col){
  1155.  char hmsg[2] = " ";
  1156.  XbWFEd_MinPort();
  1157.  hmsg[0] =msg[cur];
  1158.  XbWSGr_TLBox(x,y-XbWFGr_THeight(),
  1159.    XbWVEd_xb,XbWVEd_yb,
  1160.    msg,XbWVGr_White,col,XbWVGr_LRed);
  1161.  if (XbWSSy_TimeSec() & 1) {
  1162.    XbWSGr_TLBox(x+1+cur*XbWFGr_TWidth("M"),y-XbWFGr_THeight(),
  1163.      x+2+(cur+1)*XbWFGr_TWidth("M"),XbWVEd_yb,
  1164.      hmsg,XbWVGr_Black,XbWVGr_White,XbWVGr_Black);
  1165.    }
  1166.  else {
  1167.    XbWSGr_TLBox(x+1+cur*XbWFGr_TWidth("M"),y-XbWFGr_THeight(),
  1168.      x+2+(cur+1)*XbWFGr_TWidth("M"),XbWVEd_yb,
  1169.      hmsg,XbWVGr_White,XbWVGr_Black,XbWVGr_White);
  1170.    };
  1171.  XbWFEd_MaxPort();
  1172.  };
  1173. /*}}}  */
  1174. /*{{{  XbWFEd_OutLine(     ***    Textzeile ausgeben*/
  1175. void  XbWFEd_OutLine(void){
  1176.     char buffer[255]; int textw;
  1177.     /*
  1178.     Den Zustand des Insert- Flags anzeigen (ob Einf"ugen oder "Uberschreiben
  1179.     des strings.
  1180.     */
  1181.     XbWFEd_OutIns();
  1182.     /*
  1183.     Den aktuell zu bearbeitenden string {\bf XbWVEd_zstr } nach der Breite des
  1184.     aktuellen Fensters ausrichten. Dazu wird XbWVEd_zstr solange verkleinert, bis er
  1185.     gerade in die Editierzeile pa"st. Hier macht sich die Proportional-
  1186.     darstellung der Texte sehr angenehm bemerkbar.
  1187.     Zun"achst wird der Teil des strings bis zur Cursorposition bestimmt.
  1188.     */
  1189.     XbWVEd_lcnt = 0;
  1190.     strncpy(buffer,&XbWVEd_zstr[XbWVEd_lcnt],XbWVEd_crpos-XbWVEd_lcnt);
  1191.     buffer[XbWVEd_crpos-XbWVEd_lcnt]=0;
  1192.     textw = (XbWFGr_TWidth("M"))*strlen(buffer);
  1193.     while ((XbWVEd_lcnt < XbWVEd_crpos) &
  1194.        (textw >  XbWVEd_xb-XbWVEd_xa-5)) {
  1195.       XbWVEd_lcnt ++;
  1196.       strncpy(buffer,&XbWVEd_zstr[XbWVEd_lcnt],XbWVEd_crpos-
  1197.         XbWVEd_lcnt);
  1198.       buffer[XbWVEd_crpos-XbWVEd_lcnt+1]=0;
  1199.       textw = (XbWFGr_TWidth("M"))*strlen(buffer);
  1200.       }
  1201.  
  1202.     /*
  1203.     Wenn sich etwas ge"andert hat, mu"s der string anders ausgegeben werden.
  1204.     Dazu ist das Feld zu l"oschen, das XbWVEd_zstr belegt.
  1205.     */
  1206.     XbWFEd_MinPort();
  1207.     if ((XbWVEd_lcnt != XbWVEd_vpos) & (XbWVEd_lcnt-1 > 0)) {};
  1208.  
  1209.     {  XbWSGr_TLBox(XbWVEd_xhp,XbWVEd_yhp+1,XbWVEd_xb,XbWVEd_yb,
  1210.         NULL,XbWVGr_White,0,XbWVGr_White);};
  1211.     XbWFEd_MaxPort();
  1212.  
  1213.     /*
  1214.     Jetzt erst {\bf XbWVEd_vpos } setzen, weil sonst obige Pr"ufung fehlschlagen
  1215.     w"urde.
  1216.     */
  1217.     XbWVEd_vpos = XbWVEd_lcnt;
  1218.  
  1219.     /*
  1220.     Jetzt den aktuellen Header ausgeben. Dies ist der fr"uhestm"ogliche
  1221.     Zeitpunkt, da sich sonst die diversen "Uberpr"ufungen "uberschneiden
  1222.     w"urden.
  1223.     */
  1224.     XbWFEd_MinPort();
  1225.     XbWSGr_TLBox(XbWVEd_xhp,XbWVEd_ya+1,0,0,XbWVEd_hdr,XbWVGr_White,XbWVGr_Red,XbWVGr_White);
  1226.     XbWFEd_MaxPort();
  1227.  
  1228.     /*
  1229.     Pr"ufe, ob nach dem Cursor noch Platz f"ur den Rest des strings ist.
  1230.     Wenn ja, so viel wie m"oglich darstellen.
  1231.     */
  1232.     XbWVEd_lcnt = XbWVEd_crpos;
  1233.     strncpy(buffer,&XbWVEd_zstr[XbWVEd_vpos],XbWVEd_lcnt-XbWVEd_vpos);
  1234.     buffer[XbWVEd_lcnt-XbWVEd_vpos]=0;
  1235.     textw = strlen(buffer)*(XbWFGr_TWidth("M"));
  1236.     while ((XbWVEd_lcnt < strlen(XbWVEd_zstr)) &
  1237.         (textw < (XbWVEd_xb-XbWVEd_xa-5))){
  1238.       XbWVEd_lcnt++;
  1239.       strncpy(buffer,&XbWVEd_zstr[XbWVEd_vpos],XbWVEd_lcnt-
  1240.         XbWVEd_vpos);
  1241.       buffer[XbWVEd_lcnt-XbWVEd_vpos]=0;
  1242.       textw = strlen(buffer)*(XbWFGr_TWidth("M"));
  1243.       };
  1244.     XbWVEd_npos = XbWVEd_lcnt;
  1245.  
  1246.     /*
  1247.     Ein paar generelle checks folgen.
  1248.     */
  1249.     if (XbWVEd_vpos == strlen(XbWVEd_zstr))   {
  1250.       XbWVEd_vpos = strlen(XbWVEd_zstr)-2;}
  1251.     if (XbWVEd_vpos < 0)   {XbWVEd_vpos = 0;};
  1252.     if (XbWVEd_npos > strlen(XbWVEd_zstr))   {
  1253.       XbWVEd_npos = strlen(XbWVEd_zstr);};
  1254.  
  1255.     /*
  1256.     Jetzt den auszugebenden Text aus dem string kopieren.
  1257.     */
  1258.     strncpy(XbWVEd_coptxt,&XbWVEd_zstr[XbWVEd_vpos],XbWVEd_npos-
  1259.       XbWVEd_vpos+1);
  1260.     XbWVEd_coptxt[XbWVEd_npos-XbWVEd_vpos+1]=0;
  1261.  
  1262.     XbWVEd_send = (XbWFGr_TWidth("M"))*strlen(buffer);
  1263.     XbWFEd_MinPort();
  1264.     XbWFEd_TextXY(XbWVEd_xa,XbWVEd_yb+1,XbWVEd_crpos,XbWVEd_coptxt,
  1265.       XbWVEd_scol);
  1266.  
  1267.     XbWFEd_MinPort();
  1268.  
  1269.     /*
  1270.     Die beiden den string seitlich begrenzenden Doppelbalken ausgeben.
  1271.     */
  1272.     if ((XbWVEd_npos != strlen(XbWVEd_zstr)) &
  1273.         (strlen(XbWVEd_zstr)!=0))   {
  1274.       XbWSGr_VLin(XbWVEd_xa+XbWVEd_send+1,XbWVEd_ya+2,
  1275.         XbWVEd_yb-2,XbWVGr_Red);
  1276.       XbWSGr_VLin(XbWVEd_xa+XbWVEd_send+2,XbWVEd_ya+2,
  1277.         XbWVEd_yb-2,XbWVGr_Red);
  1278.       XbWSGr_VLin(XbWVEd_xa+XbWVEd_send+3,XbWVEd_ya+2,
  1279.         XbWVEd_yb-2,XbWVGr_Red);
  1280.       };
  1281.     if (XbWVEd_vpos != 0)   {
  1282.       XbWSGr_VLin(XbWVEd_xa-4,XbWVEd_ya+2,
  1283.         XbWVEd_yb-2,XbWVGr_Red);
  1284.       XbWSGr_VLin(XbWVEd_xa-3,XbWVEd_ya+2,
  1285.         XbWVEd_yb-2,XbWVGr_Red);
  1286.       XbWSGr_VLin(XbWVEd_xa-2,XbWVEd_ya+2,
  1287.         XbWVEd_yb-2,XbWVGr_Red);
  1288.       };
  1289.  
  1290.     };
  1291. /*}}}  */
  1292. /*{{{  XbWFEd_OutStr(      ***    Textstring ausgeben, ruft OutLine*/
  1293. void  XbWFEd_OutStr(void){
  1294.    XbWFGr_CurOFF();
  1295.    XbWFEd_MinPort();
  1296.    XbWSGr_TLBox(XbWVEd_xhp,XbWVEd_yhp+1,XbWVEd_xb,XbWVEd_yb,
  1297.      XbWVEd_hdr,
  1298.      XbWVGr_White,XbWVEd_hcol,XbWVGr_White);
  1299.    XbWFEd_OutLine();
  1300.    XbWFEd_MaxPort();
  1301.    };
  1302. /*}}}  */
  1303. /*{{{  XbWFEd_GetStr(      ***    Unterprogramm fuer Editor*/
  1304. void  XbWFEd_GetStr(void){
  1305.    int ccc,len,cursormrk;
  1306.    cursormrk = XbWVMs_CSet;
  1307.    XbWFGr_CurOFF();
  1308.    XbWVEd_nxt = Vor;
  1309.    XbWVEd_zc = ' ';XbWVEd_vpos = 0;XbWVEd_npos = 0;
  1310.    XbWVEd_hdr[12] = '.';
  1311.    XbWVEd_hdr[13] = '.';
  1312.    XbWVEd_hdr[14] = 0;
  1313.    strcpy(XbWVEd_zstr,XbWVEd_sst);XbWVEd_crpos = XbWVEd_cpos;XbWFEd_OutStr();
  1314.    XbWSMs_WButtUp();
  1315.    while (XbWVEd_zc != 13) {
  1316.      time_t oldtime = XbWSSy_TimeSec();
  1317.      XbWVMs_LButt = 0;
  1318.      while (1) {
  1319.        if (XbWSMs_IsAKey(0)){
  1320.          XbWSMs_GetKey(&XbWVEd_zf,&XbWVEd_zc);
  1321.          break;
  1322.          };
  1323.        if (XbWSSy_TimeSec() != oldtime) {
  1324.          XbWFEd_OutStr();
  1325.          oldtime = XbWSSy_TimeSec();
  1326.          };
  1327.        if (XbWVMs_LButt){
  1328.          XbWVEd_zc = 13;
  1329.          break;
  1330.          };
  1331.        };
  1332.      printf("Keys: %d %d\n",XbWVEd_zf,XbWVEd_zc);
  1333.      switch (XbWVEd_zc) {
  1334.        case 255:break;
  1335.        case (13): {XbWVEd_nxt = Vor;break;};  /* RETURN : ende mit VOR */
  1336.        case (27): {XbWVEd_nxt = EndInput; /* ESC : ende mit ENDINPUT */
  1337.                    strcpy(XbWVEd_zstr,XbWVEd_sst);XbWVEd_zc = 13;break;};
  1338.  
  1339.        /* DELETE und BACKSPACE sind wegen Linux XFree86 vertauscht! */
  1340.  
  1341.        case (8):   /* DELETE */
  1342.                    for(ccc=XbWVEd_crpos;XbWVEd_zstr[ccc]!=0;ccc++){
  1343.                      XbWVEd_zstr[ccc] = XbWVEd_zstr[ccc+1];}
  1344.                    XbWFEd_OutStr();break;
  1345.        case 7:
  1346.        case (127):  {if (XbWVEd_crpos >= 0)   { /* BackSpace */
  1347.                    for(ccc=XbWVEd_crpos-1;XbWVEd_zstr[ccc]!=0;ccc++){
  1348.                    XbWVEd_zstr[ccc] = XbWVEd_zstr[ccc+1];}
  1349.                    if (XbWVEd_crpos > 0)   {XbWVEd_crpos--;};
  1350.                    XbWFEd_OutStr();};break;};
  1351.        case (0):  {
  1352.               switch (XbWVEd_zf) {
  1353.               case ('O'): {
  1354.                         XbWVEd_crpos = strlen(XbWVEd_zstr);
  1355.                         XbWFEd_OutStr();break;}; /* End */
  1356.               case ('G'): {XbWVEd_crpos = 0;
  1357.                         XbWFEd_OutStr();break;};  /* Pos1 */
  1358.               case ('R'): {if (XbWVEd_ins == 1) {
  1359.                           XbWVEd_ins = 0;}  /* INSERT */
  1360.                         else {XbWVEd_ins = 1;};
  1361.                         XbWFEd_OutIns();break;};
  1362.               case ('S'): {if (XbWVEd_crpos >= 0)   {
  1363.                           for (ccc=XbWVEd_crpos;XbWVEd_zstr[ccc]!=0;
  1364.                             ccc++){XbWVEd_zstr[ccc]=
  1365.                               XbWVEd_zstr[ccc+1];}; /* DELETE */
  1366.                           XbWFEd_OutStr();};break;};
  1367.               case (77): {if (XbWVEd_crpos < strlen(XbWVEd_zstr)){
  1368.                           XbWVEd_crpos++;
  1369.                           XbWFEd_OutLine();};break;}; /* RECHTS */
  1370.               case (75): {if (XbWVEd_crpos > 0)   {
  1371.                           /* CURSOR links */
  1372.                           XbWVEd_crpos--;XbWFEd_OutLine();};break;};
  1373.               case (80): {XbWVEd_zc = 13;XbWVEd_nxt = CursorDown;
  1374.                         break;}; /* Cursor DOWN */
  1375.               case (72): {XbWVEd_zc = 13;XbWVEd_nxt = CursorUp;
  1376.                         break;};   /* Cursor UP */
  1377.               case (81): {XbWVEd_zc = 13;XbWVEd_nxt = PageDown;
  1378.                         break;};  /* PAGE DOWN */
  1379.               case (73): {XbWVEd_zc = 13;XbWVEd_nxt = PageUp;
  1380.                         break;}; /* PAGE UP */
  1381.               };
  1382.               break;};
  1383.        default:{
  1384.          if (XbWVEd_zc >= 20 )   {
  1385.            if (XbWVEd_ins == 1)   {
  1386.              len = strlen(XbWVEd_zstr);
  1387.              for (ccc=len+1;ccc >=XbWVEd_crpos;ccc--) {
  1388.                XbWVEd_zstr[ccc] = XbWVEd_zstr[ccc-1];}
  1389.              XbWVEd_zstr[XbWVEd_crpos] = XbWVEd_zc;XbWVEd_crpos++;
  1390.              XbWFEd_OutStr();
  1391.              }
  1392.            else {if (XbWVEd_crpos >= strlen(XbWVEd_zstr))   {
  1393.                len = strlen(XbWVEd_zstr);XbWVEd_zstr[len] = XbWVEd_zc;
  1394.                XbWVEd_zstr[len+1] = 0;}
  1395.              else {
  1396.                XbWVEd_zstr[XbWVEd_crpos] = XbWVEd_zc;};
  1397.              XbWVEd_crpos++;XbWFEd_OutStr();
  1398.            };};
  1399.          break;
  1400.          };
  1401.        };
  1402.      };
  1403.    XbWFGr_CurOFF();
  1404.    };
  1405. /*}}}  */
  1406. /*{{{  XbWFEd_GetAStr(     ***    Unterprogramm; ruft GetStr*/
  1407. void  XbWFEd_GetAStr(void) {
  1408.   int cursormrk;
  1409.   cursormrk = XbWVMs_CSet;
  1410.   XbWVEd_cpos = 0;
  1411.   XbWVEd_mvport = 0;
  1412.   XbWFEd_GetStr();
  1413.   if (cursormrk == 1) {
  1414.     XbWFGr_CurON();
  1415.     };
  1416.   };
  1417. /*}}}  */
  1418. /*{{{  XbWFEd_GetSStr(     ***    String in Standard-Texteingabezeile einlesen*/
  1419. void  XbWFEd_GetSStr(char *chdr, char *string,int MaxLen, int CurPos){
  1420.  
  1421. /* ---------------- XbWFEd_GetSStr() ---------------------------------------
  1422.    Hier wird ein String auf dem Grafikbildschirm in der Standard-Text-
  1423.    Ausgabezeile eingelesen.
  1424.    ----------------------------------------------------------------------- */
  1425.   int len;
  1426.   /*
  1427.   Wir werden den Bildschirm direkt adressieren.
  1428.   */
  1429.   if (MaxLen == 0) {
  1430.     MaxLen = strlen(string)+1;
  1431.     };
  1432.   if (MaxLen >0) {
  1433.     XbWFGr_PushPort();
  1434.     XbWVEd_cpos = CurPos;
  1435.     XbWVEd_mvport = 1;
  1436.     XbWFGr_SetPort();
  1437.  
  1438.     XbWSGr_TLBox(0,XbWSGr_GtPhysY()-XbWDWd_BordH-2,XbWSGr_GtPhysX(),
  1439.             XbWSGr_GtPhysY(),NULL,XbWVGr_White,0,XbWVGr_White);
  1440.  
  1441.     XbWVEd_xhp = 2;
  1442.     XbWVEd_yhp = XbWSGr_GtPhysY()-XbWDWd_BordH;
  1443.  
  1444.     len = strlen(chdr);
  1445.     if (len > 33) { len = 33; };
  1446.  
  1447.     strncpy(XbWVEd_hdr,chdr,len);
  1448.  
  1449.     XbWVEd_hdr[len] = 0;XbWVEd_hcol = XbWVGr_Red;
  1450.     XbWVEd_xa = XbWVEd_xhp + XbWFGr_TWidth(XbWVEd_hdr)+10;
  1451.     XbWVEd_ya = XbWVEd_yhp;
  1452.     XbWVEd_xb = 500;
  1453.     XbWVEd_yb = XbWSGr_GtPhysY()-3;
  1454.  
  1455.     strcpy(XbWVEd_sst,string);XbWVEd_sst[255] = 0;XbWVEd_scol = XbWVGr_Blue;
  1456.     XbWFEd_GetStr();
  1457.  
  1458.     XbWVEd_zstr[MaxLen-1] = 0;
  1459.     strcat(XbWVEd_zstr,"                                           ");
  1460.     strncpy((char *)string,XbWVEd_zstr,MaxLen-1);
  1461.     string[MaxLen-1] = 0;
  1462.     XbWFGr_PopPort();
  1463.     XbWFGr_ResPort();
  1464.     };
  1465.   };
  1466. /*}}}  */
  1467. /*{{{  XbWFEd_GetOStr(     ***    String im Objekt einlesen (xa,ya,xb,yb...)*/
  1468. void  XbWFEd_GetOStr(XbWDDb_DbIWdw  *WI,char *string,int MaxLen,
  1469.     int XA, int YA, int XB, int YB,char *defaultmsg, int cpo){
  1470.   int cursormrk;
  1471.   cursormrk = XbWVMs_CSet;
  1472.   XbWVEd_cpos = cpo;
  1473.   XbWFGr_CurOFF();
  1474.   if (XbWVEd_cpos > strlen(string) ){
  1475.     XbWVEd_cpos = strlen(string);
  1476.     };
  1477.   XbWVEd_mvport = 0;
  1478.   if (MaxLen == 0) {MaxLen = strlen(string)+1;};
  1479.   if (MaxLen >0) {
  1480.     XbWFGr_PushPort();
  1481.     XbWFTb_Message(defaultmsg);
  1482.     XbWFGr_MinPort(
  1483.       *WI->nx+5,*WI->ny+*WI->sy+2,
  1484.       *WI->nx+*WI->sx+3,*WI->ny+*WI->sy-2);
  1485.     XbWFGr_PopPort();
  1486.     XbWFGr_ResPort();
  1487.     XbWFGr_PushPort();
  1488.  
  1489.     XbWVEd_xhp = XA;
  1490.     XbWVEd_yhp = YA;
  1491.     strcpy(XbWVEd_hdr,"");
  1492.  
  1493.     XbWVEd_xa = XA;
  1494.     XbWVEd_ya = YA;
  1495.     XbWVEd_xb = XB;
  1496.     XbWVEd_yb = YB;
  1497.     strcpy(XbWVEd_sst,string);
  1498.     XbWVEd_sst[255] = 0;
  1499.     XbWVEd_scol = XbWVGr_Blue;
  1500.     XbWVEd_mvport = 0;
  1501.     XbWFEd_GetStr();
  1502.     if (cursormrk == 1) {
  1503.       XbWFGr_CurON();
  1504.       };
  1505.     XbWVEd_zstr[MaxLen-1] = 0;
  1506.     strcat(XbWVEd_zstr,"                                           ");
  1507.     XbWVEd_zstr[MaxLen] = 0;
  1508.     strncpy((char *)string,XbWVEd_zstr,MaxLen-1);
  1509.     string[MaxLen] = 0;
  1510.     XbWFTb_Message(".");
  1511.     XbWFGr_PopPort(); XbWFGr_ResPort();
  1512.     };
  1513.   };
  1514. /*}}}  */
  1515.  
  1516. /*{{{  XbWFMx_RWGrp(       ***    Unterroutine zum MFX-Gruppe schreiben/lesen*/
  1517. int  XbWFMx_RWGrp(char *rgr_nm, char* rgr_rwm,
  1518.                          int rw_smode, int rw_snr, char *new_filnm){
  1519.   char *rw_filnam,*rw_mode;
  1520.   XbWDDb_DbINPtr  *rw_filitm;
  1521.   XbWDDb_DbINPtr  *rw_itm;
  1522.   char sstr[80];
  1523.   char rgr_name[60];
  1524.  
  1525.   rw_filitm = (XbWDDb_DbINPtr *)XbWFDb_GetDbI("MFX",rgr_nm,"fil");
  1526.   if (rw_filitm == NULL) {return(1);};
  1527.  
  1528.   rw_filnam = XbWFTb_PckTxt((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)rw_filitm));
  1529.   if (new_filnm != NULL) {
  1530.     rw_filnam = new_filnm;
  1531.     };
  1532.   if (rw_filnam == NULL) {return(1);};
  1533.   switch(rw_smode){
  1534.     case 0: strcpy(rgr_name,rgr_nm);
  1535.             break;
  1536.     case 1: if (strchr(rw_filnam,'.') != NULL) {
  1537.               char nsstr[40];
  1538.               sprintf(nsstr,".%d",rw_snr);
  1539.               strcpy(strchr(rw_filnam,'.'),nsstr);
  1540.               }
  1541.             else {
  1542.               sprintf(rw_filnam,"%s.%d",rgr_nm,rw_snr);
  1543.               };
  1544.             strcpy(rgr_name,rgr_nm);
  1545.             break;
  1546.     case 2: if (strchr(rw_filnam,'.') != NULL) {
  1547.               char nsstr[40];
  1548.               int b,a;
  1549.               b = rw_snr/10;
  1550.               if (b>9) {
  1551.                 b=b - (b/100)*100;
  1552.                 };
  1553.               a = rw_snr;
  1554.               if (a > 9) {
  1555.                 a=a - (a/10)*10;
  1556.                 };
  1557.               sprintf(nsstr,".%d%d%d",(rw_snr/100),b,a);
  1558.               strcpy(strchr(rw_filnam,'.'),nsstr);
  1559.               }
  1560.             else {
  1561.               int b,a;
  1562.               b = rw_snr/10;
  1563.               if (b>9) {
  1564.                 b=b - (b/100)*100;
  1565.                 };
  1566.               a = rw_snr;
  1567.               if (a > 9) {
  1568.                 a=a - (a/10)*10;
  1569.                 };
  1570.               sprintf(rw_filnam,"%s.%d%d%d",rgr_nm,(rw_snr/100),b,a);
  1571.               };
  1572.             strcpy(rgr_name,rgr_nm);
  1573.             break;
  1574.     };
  1575.  
  1576.   rw_mode = rgr_rwm;
  1577.   switch (rw_mode[0]) {
  1578.     case 'R': XbWFMx_RdSet(rw_filnam,rgr_name); break;
  1579.     case 'W': XbWFMx_WrSet(rw_filnam,rgr_name,0); break;
  1580.     case 'A': XbWFMx_WrSet(rw_filnam,rgr_name,1); break;
  1581.     default:return(1);
  1582.     };
  1583.  
  1584.   switch(rw_smode){
  1585.     case 0: sprintf(sstr,"%s MFX-Group %s...",rgr_rwm,rgr_name);
  1586.             break;
  1587.     case 2:
  1588.     case 1: sprintf(sstr,"%s MFX-Group %s set %d...",rgr_rwm,rgr_nm,rw_snr);
  1589.             break;
  1590.     };
  1591.   XbWFTb_Message(sstr);
  1592.  
  1593.   while(rw_filitm !=NULL) {
  1594.     XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  1595.     while (strncmp(rw_filitm->nm,"  ArraySize",strlen("  ArraySize"))==0){
  1596.       XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  1597.       };
  1598.  
  1599.     if (rw_filitm != NULL) {
  1600.       if (XbWVMf_prd){
  1601.         if ((((XbWDDb_DbIVar  *)rw_filitm)->tp & XbWDDb_Typ) == XbWDDb_GPtr){
  1602.           printf("XbW: XBCOM finds End Of MFX Group of file %s\n",rw_filnam);
  1603.           }
  1604.         else {
  1605.           if (rw_mode[0]=='R'){
  1606.             printf("XbW: XBCOM reads %s from %s\n",rw_filitm->nm,rw_filnam);
  1607.             }
  1608.           else {
  1609.             printf("XbW: XBCOM writes %s to %s\n",rw_filitm->nm,rw_filnam);
  1610.             };
  1611.           };
  1612.         };
  1613.  
  1614.       switch (((XbWDDb_DbIVar  *)rw_filitm)->tp & XbWDDb_Typ) {
  1615.         case XbWDDb_Int:
  1616.           if (rw_mode[0] == 'R'){
  1617.             XbWFMx_GetInt((int*)&((XbWDDb_DbIInt *)rw_filitm)->inh);
  1618.             }
  1619.           else {
  1620.             XbWFMx_PutInt(*(int*)&((XbWDDb_DbIInt *)rw_filitm)->inh,
  1621.               (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1622.             };
  1623.           break;
  1624.         case XbWDDb_Dbl:
  1625.           if (rw_mode[0] == 'R'){
  1626.             XbWFMx_GetDbl((double*)& ((XbWDDb_DbIDbl*)rw_filitm)->inh);
  1627.             }
  1628.           else {
  1629.             XbWFMx_PutDbl(*(double*)& ((XbWDDb_DbIDbl*)rw_filitm)->inh,
  1630.               (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1631.             };
  1632.           break;
  1633.         case XbWDDb_Str:
  1634.           if (rw_mode[0] == 'R'){
  1635.             XbWFMx_GetStr((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)rw_filitm));
  1636.             }
  1637.           else {
  1638.             XbWFMx_PutStr((char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)rw_filitm),
  1639.               (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1640.             };
  1641.           break;
  1642.  
  1643.         case XbWDDb_NPtr:
  1644.           if (rw_filitm->inh != 0) {
  1645.             rw_itm = (XbWDDb_DbINPtr  *)rw_filitm;
  1646.             while ((rw_itm->tp & XbWDDb_Typ)== XbWDDb_NPtr){
  1647.               if (rw_itm->inh == 0) { rw_itm = NULL;}
  1648.               else {
  1649.                 rw_itm = (XbWDDb_DbINPtr  *)XbWFDb_CDbIToPtr(rw_itm->inh,XbWDDb_DbISys);
  1650.                 };
  1651.               };
  1652.             if (rw_itm != NULL) {
  1653.               switch (rw_mode[0]) {
  1654.                 case 'R':
  1655.                   switch(rw_itm->tp & XbWDDb_Typ) {
  1656.                     case XbWDDb_Int:
  1657.                       XbWFMx_GetInt((int*)&((XbWDDb_DbIInt *)rw_itm)->inh); break;
  1658.                     case XbWDDb_Dbl:
  1659.                       XbWFMx_GetDbl((double*)& ((XbWDDb_DbIDbl*)rw_itm)->inh); break;
  1660.                     case XbWDDb_Str:
  1661.                       XbWFMx_GetStr((char*)XbWFDb_GetStr((XbWDDb_DbIStr *)rw_itm)); break;
  1662.                     default:;
  1663.                     };
  1664.                 case 'W':
  1665.                 case 'A':
  1666.                   switch(rw_itm->tp & XbWDDb_Typ) {
  1667.                     case XbWDDb_Int:
  1668.                       XbWFMx_PutInt(*((int*)&((XbWDDb_DbIInt *)rw_itm)->inh),
  1669.                         (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm)); break;
  1670.                     case XbWDDb_Dbl:
  1671.                       XbWFMx_PutDbl(*((double*)& ((XbWDDb_DbIDbl*)rw_itm)->inh),
  1672.                         (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm)); break;
  1673.                     case XbWDDb_Str:
  1674.                       XbWFMx_PutStr((char*)XbWFDb_GetStr((XbWDDb_DbIStr *)rw_itm),
  1675.                         (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm)); break;
  1676.                     default:;
  1677.                     };
  1678.                 };
  1679.               };
  1680.             };
  1681.           break;
  1682.         case XbWDDb_GPtr: rw_filitm = NULL; break;
  1683.         default:      rw_filitm = NULL; break;
  1684.         };
  1685.       };
  1686.     };
  1687.   switch (rw_mode[0]) {
  1688.     case 'W': XbWFMx_EndSet(); break;
  1689.     case 'A': XbWFMx_EndSet(); break;
  1690.     };
  1691.   XbWFMx_Close();
  1692.   sprintf(sstr,"%s MFX-Group %s done!",rgr_rwm,rgr_name);
  1693.   XbWFTb_Message(sstr);
  1694.   return(0);
  1695.   };
  1696. /*}}}  */
  1697. /*{{{  XbWFMx_CrGrp(       ***    Headerdatei fuer MFX-Gruppe erstellen*/
  1698. int  XbWFMx_CrGrp(char *cgr_name){
  1699.   /*{{{  Variablen*/
  1700.   int max_brace=0;
  1701.   char rw_filnam[60];
  1702.   char *sstr,*iomfname;
  1703.   XbWDDb_DbINPtr  *rw_filitm;
  1704.   XbWDDb_DbINPtr  *rw_start;
  1705.   XbWDDb_DbIVar  *rw_itm;
  1706.   char *default_return = ",\n";
  1707.   char *start_return = "\n";
  1708.   char *akt_return;
  1709.   FILE *fp;
  1710.   
  1711.   /*}}}  */
  1712.   /*{{{  Datenstruktur fuer Gruppe erzeugen*/
  1713.   rw_filitm = (XbWDDb_DbINPtr *)XbWFDb_GetDbI("MFX",cgr_name,"C-Files");
  1714.   if (rw_filitm == NULL) {return(1);};
  1715.   
  1716.   sstr = (char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)rw_filitm);
  1717.   if (sstr == NULL) {return(1);};
  1718.   
  1719.   sprintf(rw_filnam,"%s%s.xbh",sstr,cgr_name);
  1720.   
  1721.   if ((fp = XbWSSy_fopen(rw_filnam,"wt")) == NULL) {return(1);};
  1722.   
  1723.   rw_filitm = (XbWDDb_DbINPtr *)XbWFDb_GetDbI("MFX",cgr_name,"fil");
  1724.   if (rw_filitm == NULL) {return(1);};
  1725.   
  1726.   iomfname = (char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)rw_filitm);
  1727.   if (iomfname == NULL) {
  1728.     fclose(fp);
  1729.     return(1);
  1730.     };
  1731.   
  1732.   fprintf(fp,"/* IO-Struct Descr for group %s created by XW */\n\n",cgr_name);
  1733.   
  1734.   fprintf(fp,"typedef struct {\n");
  1735.   
  1736.   rw_start = rw_filitm;
  1737.   
  1738.   akt_return = start_return;
  1739.   while(rw_filitm !=NULL) {
  1740.     int array_x=0, array_y=0;
  1741.     XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  1742.     if (strncmp(rw_filitm->nm,"  ArraySize",strlen("  ArraySize"))==0){
  1743.       /*{{{  */
  1744.       array_x = *(int*)&((XbWDDb_DbIInt *)rw_filitm)->inh;
  1745.       XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  1746.       if (strncmp(rw_filitm->nm,"  ArraySize",strlen("  ArraySize"))==0){
  1747.         array_y = *(int*)&((XbWDDb_DbIInt *)rw_filitm)->inh;
  1748.         XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  1749.         };
  1750.       };
  1751.       
  1752.       /*}}}  */
  1753.     if (rw_filitm != NULL) {
  1754.       switch (((XbWDDb_DbIVar  *)rw_filitm)->tp & XbWDDb_Typ) {
  1755.         case XbWDDb_Int:
  1756.           /*{{{  */
  1757.           if (array_x+array_y){
  1758.             char sstr[40];
  1759.             strcpy(sstr,(char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1760.             if (strchr(sstr,'[') != NULL){
  1761.               strcpy(strchr(sstr,'['),"\0");
  1762.               };
  1763.             fprintf(fp,akt_return);
  1764.             if ( (array_x!=0) & (array_y!=0)){
  1765.               fprintf(fp," int %s[%d][%d]", sstr, array_x,array_y);
  1766.               }
  1767.             else {
  1768.               if (!array_x){
  1769.                 fprintf(fp," int %s[%d]", sstr, array_y);
  1770.                 };
  1771.               if (!array_y){
  1772.                 fprintf(fp," int %s[%d]", sstr, array_x);
  1773.                 };
  1774.               };
  1775.             }
  1776.           else {
  1777.             fprintf(fp,akt_return);
  1778.             fprintf(fp," int %s",
  1779.               (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1780.             };
  1781.           break;
  1782.           
  1783.           /*}}}  */
  1784.         case XbWDDb_Dbl:
  1785.           /*{{{  */
  1786.           if (array_x+array_y){
  1787.             char sstr[40];
  1788.             strcpy(sstr,(char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1789.             if (strchr(sstr,'[') != NULL){
  1790.               strcpy(strchr(sstr,'['),"\0");
  1791.               };
  1792.             fprintf(fp,akt_return);
  1793.             if ( (array_x!=0) & (array_y!=0)){
  1794.               fprintf(fp," double %s[%d][%d]", sstr, array_x,array_y);
  1795.               }
  1796.             else {
  1797.               if (!array_x){
  1798.                 fprintf(fp," double %s[%d]", sstr, array_y);
  1799.                 };
  1800.               if (!array_y){
  1801.                 fprintf(fp," double %s[%d]", sstr, array_x);
  1802.                 };
  1803.               };
  1804.             }
  1805.           else {
  1806.             fprintf(fp,akt_return);
  1807.             fprintf(fp," double %s",
  1808.               (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1809.             };
  1810.           break;
  1811.           /*}}}  */
  1812.         case XbWDDb_Str:
  1813.           /*{{{  */
  1814.           if (array_x+array_y){
  1815.             char sstr[40];
  1816.             strcpy(sstr,(char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1817.             if (strchr(sstr,'[') != NULL){
  1818.               strcpy(strchr(sstr,'['),"\0");
  1819.               };
  1820.             fprintf(fp,akt_return);
  1821.             if ( (array_x!=0) & (array_y!=0)){
  1822.               fprintf(fp," char %s[%d][%d][205]", sstr, array_x,array_y);
  1823.               }
  1824.             else {
  1825.               if (!array_x){
  1826.                 fprintf(fp," char %s[%d][205]", sstr, array_y);
  1827.                 };
  1828.               if (!array_y){
  1829.                 fprintf(fp," char %s[%d][205]", sstr, array_x);
  1830.                 };
  1831.               };
  1832.             break;
  1833.             }
  1834.           else {
  1835.             fprintf(fp,akt_return);
  1836.             fprintf(fp," char %s[205]",
  1837.               (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1838.             };
  1839.           break;
  1840.           /*}}}  */
  1841.         case XbWDDb_NPtr:
  1842.           /*{{{  */
  1843.           if (rw_filitm->inh != 0) {
  1844.             rw_itm = (XbWDDb_DbIVar *)XbWFDb_CDbIToPtr(rw_filitm->inh,XbWDDb_DbISys);
  1845.             if (rw_itm != NULL) {
  1846.               switch(rw_itm->tp & XbWDDb_Typ) {
  1847.                 case XbWDDb_Int:
  1848.                   if (array_x+array_y){
  1849.                     char sstr[40];
  1850.                     strcpy(sstr,(char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1851.                     if (strchr(sstr,'[') != NULL){
  1852.                       strcpy(strchr(sstr,'['),"\0");
  1853.                       };
  1854.                     fprintf(fp,akt_return);
  1855.                     if ( (array_x!=0) & (array_y!=0)){
  1856.                       fprintf(fp," double %s[%d][%d]", sstr, array_x,array_y);
  1857.                       }
  1858.                     else {
  1859.                       if (!array_x){
  1860.                         fprintf(fp," double %s[%d]", sstr, array_y);
  1861.                         };
  1862.                       if (!array_y){
  1863.                         fprintf(fp," double %s[%d]", sstr, array_x);
  1864.                         };
  1865.                       };
  1866.                     }
  1867.                   else {
  1868.                     fprintf(fp,akt_return);
  1869.                     fprintf(fp," int %s",
  1870.                       (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm)); break;
  1871.                     };
  1872.                 case XbWDDb_Dbl:
  1873.                   if (array_x+array_y){
  1874.                     char sstr[40];
  1875.                     strcpy(sstr,(char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1876.                     if (strchr(sstr,'[') != NULL){
  1877.                       strcpy(strchr(sstr,'['),"\0");
  1878.                       };
  1879.                     fprintf(fp,akt_return);
  1880.                     if ( (array_x!=0) & (array_y!=0)){
  1881.                       fprintf(fp," int %s[%d][%d]", sstr, array_x,array_y);
  1882.                       }
  1883.                     else {
  1884.                       if (!array_x){
  1885.                         fprintf(fp," int %s[%d]", sstr, array_y);
  1886.                         };
  1887.                       if (!array_y){
  1888.                         fprintf(fp," int %s[%d]", sstr, array_x);
  1889.                         };
  1890.                       };
  1891.                     }
  1892.                   else {
  1893.                     fprintf(fp,akt_return);
  1894.                     fprintf(fp," double %s",
  1895.                       (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm)); break;
  1896.                     };
  1897.                 case XbWDDb_Str:
  1898.                   if (array_x+array_y){
  1899.                     char sstr[40];
  1900.                     strcpy(sstr,(char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1901.                     if (strchr(sstr,'[') != NULL){
  1902.                       strcpy(strchr(sstr,'['),"\0");
  1903.                       };
  1904.                     fprintf(fp,akt_return);
  1905.                     if ( (array_x!=0) & (array_y!=0)){
  1906.                       fprintf(fp," char %s[%d][%d][205]", sstr, array_x,array_y);
  1907.                       }
  1908.                     else {
  1909.                       if (!array_x){
  1910.                         fprintf(fp," char %s[%d][205]", sstr, array_y);
  1911.                         };
  1912.                       if (!array_y){
  1913.                         fprintf(fp," char %s[%d][205]", sstr, array_x);
  1914.                         };
  1915.                       };
  1916.                     break;
  1917.                     }
  1918.                   else {
  1919.                     fprintf(fp,akt_return);
  1920.                     fprintf(fp," char %s[205]",
  1921.                       (char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm)); break;
  1922.                     };
  1923.                 default:;
  1924.                 };
  1925.               };
  1926.             };
  1927.           break;
  1928.           /*}}}  */
  1929.         case XbWDDb_GPtr: rw_filitm = NULL; break;
  1930.         default:      rw_filitm = NULL; break;
  1931.         };
  1932.       if (array_x+array_y){
  1933.         int kk; int kmax;
  1934.         kmax = array_x*array_y;
  1935.         if (!array_x){ kmax = array_y; };
  1936.         if (!array_y){ kmax = array_x; };
  1937.         for (kk=1;kk<kmax;kk++){
  1938.           XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  1939.           };
  1940.         };
  1941.       };
  1942.     akt_return = ";\n";
  1943.     };
  1944.   fprintf(fp,";\n} DATA_%s;\n\n",cgr_name);
  1945.   fprintf(fp,"extern DATA_%s %s;\n\n",cgr_name,cgr_name);
  1946.   
  1947.   fclose(fp);
  1948.   /*}}}  */
  1949.   /*{{{  Read MFX Gruppe*/
  1950.   rw_filitm = (XbWDDb_DbINPtr *)XbWFDb_GetDbI("MFX",cgr_name,"C-Files");
  1951.   if (rw_filitm == NULL) {return(1);};
  1952.   sstr = (char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)rw_filitm);
  1953.   if (sstr == NULL) {return(1);};
  1954.   sprintf(rw_filnam,"%s%s.xbc",sstr,cgr_name);
  1955.   if ((fp = XbWSSy_fopen(rw_filnam,"wt")) == NULL) {return(1);};
  1956.   rw_filitm = (XbWDDb_DbINPtr *)XbWFDb_GetDbI("MFX",cgr_name,"fil");
  1957.   if (rw_filitm == NULL) {return(1);};
  1958.   iomfname = (char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)rw_filitm);
  1959.   if (iomfname == NULL) {
  1960.     fclose(fp);
  1961.     return(1);
  1962.     };
  1963.   
  1964.   fprintf(fp,"/* XbW-Headerfile for group %s created by XbW */\n\n",cgr_name);
  1965.   fprintf(fp,"int XbWReadMFX%s(DATA_%s *grp, char *filename, char *datensatz){\n",cgr_name, cgr_name);
  1966.   fprintf(fp,"  int err;\n");
  1967.   fprintf(fp,"  if (grp == NULL) { grp = &%s; };\n",cgr_name );
  1968.   { int kk;
  1969.     char sstr[100];
  1970.     strcpy(sstr,cgr_name);
  1971.     for (kk=0;kk<strlen(sstr);kk++){
  1972.       if ( (sstr[kk] >= 'A')&(sstr[kk] <= 'Z')){
  1973.         sstr[kk] |= 0x20;
  1974.         };
  1975.       };
  1976.     fprintf(fp,"  if (filename == NULL) { filename = \"%s.mfx\"; }; \n",sstr);
  1977.     };
  1978.   fprintf(fp,"  if (datensatz == NULL) { datensatz = \"%s\"; };\n",cgr_name);
  1979.   fprintf(fp,"  if ((err=XbWFMx_RdSet(filename,datensatz)) != XbWDMx_RDok) {\n");
  1980.   fprintf(fp,"    return(err);\n");
  1981.   fprintf(fp,"    };\n");
  1982.   rw_start = rw_filitm;
  1983.   while(rw_filitm !=NULL) {
  1984.     char var_nam[40], grp_nam[40];
  1985.     XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  1986.     while (strncmp(rw_filitm->nm,"  ArraySize",strlen("  ArraySize"))==0){
  1987.       XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  1988.       };
  1989.   
  1990.     if (rw_filitm != NULL) {
  1991.       strcpy(var_nam,(char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  1992.       strcpy(grp_nam,cgr_name);
  1993.       switch (((XbWDDb_DbIVar  *)rw_filitm)->tp & XbWDDb_Typ) {
  1994.         case XbWDDb_Int:
  1995.           fprintf(fp,"  if (XbWFMx_GetInt((int*)&grp->%s)!=XbWDMx_RDok){ goto RDerror; };\n",
  1996.             var_nam); break;
  1997.         case XbWDDb_Dbl:
  1998.           fprintf(fp,"  if (XbWFMx_GetDbl((double*)&grp->%s)!=XbWDMx_RDok){ goto RDerror; };\n",
  1999.             var_nam); break;
  2000.         case XbWDDb_Str:
  2001.           fprintf(fp,"  if (XbWFMx_GetStr((char*)grp->%s)!=XbWDMx_RDok){ goto RDerror; };\n",
  2002.             var_nam); break;
  2003.         case XbWDDb_NPtr:
  2004.           if (rw_filitm->inh != 0) {
  2005.             rw_itm = (XbWDDb_DbIVar *)XbWFDb_CDbIToPtr(rw_filitm->inh,XbWDDb_DbISys);
  2006.             if (rw_itm != NULL) {
  2007.               switch(rw_itm->tp & XbWDDb_Typ) {
  2008.                 case XbWDDb_Int:
  2009.                   fprintf(fp,"  if (XbWFMx_GetInt((int*)&grp->%s)!=XbWDMx_RDok){ goto RDerror; };\n",
  2010.                     var_nam); break;
  2011.                 case XbWDDb_Dbl:
  2012.                   fprintf(fp,"  if (XbWFMx_GetDbl((double*)&grp->%s)!=XbWDMx_RDok){ goto RDerror; };\n",
  2013.                     var_nam); break;
  2014.                 case XbWDDb_Str:
  2015.                   fprintf(fp,"  if (XbWFMx_GetStr((char*)grp->%s)!=XbWDMx_RDok){ goto RDerror; };\n",
  2016.                     var_nam); break;
  2017.                 default:;
  2018.                 };
  2019.               };
  2020.             };
  2021.           break;
  2022.         case XbWDDb_GPtr: rw_filitm = NULL; break;
  2023.         default:      rw_filitm = NULL; break;
  2024.         };
  2025.       };
  2026.     };
  2027.   fprintf(fp,"  XbWFMx_Close();\n");
  2028.   fprintf(fp,"  return(XbWDMx_RDok);\n");
  2029.   fprintf(fp,"RDerror:;\n");
  2030.   fprintf(fp,"  XbWFMx_Close();\n");
  2031.   fprintf(fp,"  return(err);\n  };\n\n");
  2032.   /*}}}  */
  2033.   /*{{{  Write MFX Gruppe*/
  2034.   rw_filitm = (XbWDDb_DbINPtr *)XbWFDb_GetDbI("MFX",cgr_name,"C-Files");
  2035.   if (rw_filitm == NULL) {return(1);};
  2036.   sstr = (char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)rw_filitm);
  2037.   if (sstr == NULL) {return(1);};
  2038.   sprintf(rw_filnam,"%s%s.xbc",sstr,cgr_name);
  2039.   
  2040.   rw_filitm = (XbWDDb_DbINPtr *)XbWFDb_GetDbI("MFX",cgr_name,"fil");
  2041.   if (rw_filitm == NULL) {return(1);};
  2042.   iomfname = (char*)XbWFDb_GetStr((XbWDDb_DbIStr  *)rw_filitm);
  2043.   
  2044.   fprintf(fp,"/* XbW-Headerfile for group %s created by XbW */\n\n",cgr_name);
  2045.   fprintf(fp,"int XbWWriteMFX%s(DATA_%s *grp, char *filename, char *datensatz){\n",cgr_name, cgr_name);
  2046.   fprintf(fp,"  int err;\n");
  2047.   fprintf(fp,"  if (grp == NULL) { grp = &%s; };\n",cgr_name );
  2048.   fprintf(fp,"  if (filename == NULL) { filename = \"%s.mfx\"; }; \n",cgr_name);
  2049.   fprintf(fp,"  if (datensatz == NULL) { datensatz = \"%s\"; };\n",cgr_name);
  2050.   fprintf(fp,"  if ((err=XbWFMx_WrSet(filename,datensatz,0)) != XbWDMx_WRok) {\n");
  2051.   fprintf(fp,"    return(err);\n");
  2052.   fprintf(fp,"    };\n");
  2053.   rw_start = rw_filitm;
  2054.   while(rw_filitm !=NULL) {
  2055.     char var_nam[40], grp_nam[40];
  2056.     XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  2057.     while (strncmp(rw_filitm->nm,"  ArraySize",strlen("  ArraySize"))==0){
  2058.       XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  2059.       };
  2060.   
  2061.     if (rw_filitm != NULL) {
  2062.       strcpy(var_nam,(char*)XbWFDb_GetNam((XbWDDb_DbIVar *)rw_filitm));
  2063.       strcpy(grp_nam,cgr_name);
  2064.       switch (((XbWDDb_DbIVar  *)rw_filitm)->tp & XbWDDb_Typ) {
  2065.         case XbWDDb_Int:
  2066.           fprintf(fp,"  XbWFMx_PutInt((int)grp->%s,\"%s\");\n",
  2067.             var_nam,var_nam); break;
  2068.         case XbWDDb_Dbl:
  2069.           fprintf(fp,"  XbWFMx_PutDbl((double)grp->%s,\"%s\");\n",
  2070.             var_nam,var_nam); break;
  2071.         case XbWDDb_Str:
  2072.           fprintf(fp,"  XbWFMx_PutStr((char*)grp->%s,\"%s\");\n",
  2073.             var_nam,var_nam); break;
  2074.         case XbWDDb_NPtr:
  2075.           if (rw_filitm->inh != 0) {
  2076.             rw_itm = (XbWDDb_DbIVar *)XbWFDb_CDbIToPtr(rw_filitm->inh,XbWDDb_DbISys);
  2077.             if (rw_itm != NULL) {
  2078.               switch(rw_itm->tp & XbWDDb_Typ) {
  2079.                 case XbWDDb_Int:
  2080.                   fprintf(fp,"  XbWFMx_PutInt((int)grp->%s,\"%s\");\n",
  2081.                     var_nam,var_nam); break;
  2082.                 case XbWDDb_Dbl:
  2083.                   fprintf(fp,"  XbWFMx_PutDbl((double)grp->%s,\"%s\");\n",
  2084.                     var_nam,var_nam); break;
  2085.                 case XbWDDb_Str:
  2086.                   fprintf(fp,"  XbWFMx_PutStr((char*)grp->%s,\"%s\");\n",
  2087.                     var_nam,var_nam); break;
  2088.                 default:;
  2089.                 };
  2090.               };
  2091.             };
  2092.           break;
  2093.         case XbWDDb_GPtr: rw_filitm = NULL; break;
  2094.         default:      rw_filitm = NULL; break;
  2095.         };
  2096.       };
  2097.     };
  2098.   fprintf(fp,"  XbWFMx_EndSet();\n");
  2099.   fprintf(fp,"  XbWFMx_Close();\n");
  2100.   fprintf(fp,"  return(XbWDMx_WRok);\n");
  2101.   fprintf(fp,"  XbWFMx_EndSet();\n");
  2102.   fprintf(fp,"  XbWFMx_Close();\n");
  2103.   fprintf(fp,"  return(err);\n  };\n\n");
  2104.   /*}}}  */
  2105.   /*{{{  Datenstruktur fuer Initialisierung der Gruppe*/
  2106.   fprintf(fp,"DATA_%s %s={\n",cgr_name,cgr_name);
  2107.   rw_filitm = rw_start;
  2108.   akt_return = start_return;
  2109.   {
  2110.     int array_x = 0;
  2111.     int array_y = 0;
  2112.     int start_brace=0;
  2113.     /*{{{  */
  2114.     max_brace = 0;
  2115.     while(rw_filitm !=NULL) {
  2116.       XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  2117.       if (rw_filitm != NULL) {
  2118.         if (strncmp(rw_filitm->nm,"  ArraySize",strlen("  ArraySize"))==0){
  2119.           /*{{{  */
  2120.           max_brace=0;
  2121.           start_brace=1;
  2122.           array_x = *(int*)&((XbWDDb_DbIInt *)rw_filitm)->inh;
  2123.           XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  2124.           if (strncmp(rw_filitm->nm,"  ArraySize",strlen("  ArraySize"))==0){
  2125.             array_y = *(int*)&((XbWDDb_DbIInt *)rw_filitm)->inh;
  2126.             XbWFDb_ForWd((XbWDDb_DbIVar  **)&rw_filitm,XbWDDb_DbISys);
  2127.             };
  2128.           if (!array_x){ max_brace=array_y;};
  2129.           if (!array_y){ max_brace=array_x;};
  2130.           fprintf(fp,akt_return);
  2131.           fprintf(fp,"{");
  2132.           
  2133.           };
  2134.           
  2135.           /*}}}  */
  2136.         switch (((XbWDDb_DbIVar  *)rw_filitm)->tp & XbWDDb_Typ) {
  2137.           case XbWDDb_Int:
  2138.             /*{{{  */
  2139.             if (!start_brace){ fprintf(fp,akt_return); };
  2140.             fprintf(fp," %d",
  2141.               (int)(XbWFDb_GetNum((XbWDDb_DbIVar *)rw_filitm,NULL,1)) ); break;
  2142.             /*}}}  */
  2143.           case XbWDDb_Dbl:
  2144.             /*{{{  */
  2145.             if (!start_brace){ fprintf(fp,akt_return); };
  2146.             fprintf(fp," %19.7f",
  2147.               (double)(XbWFDb_GetNum((XbWDDb_DbIVar *)rw_filitm,NULL,1)) ); break;
  2148.             /*}}}  */
  2149.           case XbWDDb_Str:
  2150.             /*{{{  */
  2151.             {
  2152.               char *ms;
  2153.               char sstr[200];
  2154.               int vtp,ii,ee;
  2155.               int SL;
  2156.               XbWFDb_GetInf((XbWDDb_DbIVar *)rw_filitm, 0, NULL, &vtp, &ms, &SL, 1);
  2157.             
  2158.               strcpy(sstr,ms);
  2159.             
  2160.               ee = 0;
  2161.               for (ii=0; ii<SL-2; ii++) {
  2162.                 if (ee) {
  2163.                   sstr[ii] = ' ';
  2164.                   }
  2165.                 else {
  2166.                   switch (sstr[ii]) {
  2167.                     case 10: sstr[ii] = ' '; ee = 1; break;
  2168.                     case 13: sstr[ii] = ' '; ee = 1; break;
  2169.                     case  0: sstr[ii] = ' '; ee = 1; break;
  2170.                     };
  2171.                   };
  2172.                 };
  2173.               sstr[SL] = 0;
  2174.             
  2175.               if (!start_brace){ fprintf(fp,akt_return); };
  2176.               fprintf(fp," \"%s\"",sstr);
  2177.             
  2178.               };
  2179.             break;
  2180.             
  2181.             /*}}}  */
  2182.           case XbWDDb_NPtr:
  2183.             /*{{{  */
  2184.             if (rw_filitm->inh != 0) {
  2185.               rw_itm = (XbWDDb_DbIVar *)XbWFDb_CDbIToPtr(rw_filitm->inh,XbWDDb_DbISys);
  2186.               if (rw_itm != NULL) {
  2187.                 switch(rw_itm->tp & XbWDDb_Typ) {
  2188.                   case XbWDDb_Int:
  2189.                     if (!start_brace){ fprintf(fp,akt_return); };
  2190.                     fprintf(fp," %d",
  2191.                       (int)(XbWFDb_GetNum((XbWDDb_DbIVar *)rw_filitm,NULL,1)) ); break;
  2192.                   case XbWDDb_Dbl:
  2193.                     if (!start_brace){ fprintf(fp,akt_return); };
  2194.                     fprintf(fp," %19.7f",
  2195.                       (double)(XbWFDb_GetNum((XbWDDb_DbIVar *)rw_filitm,NULL,1)) ); break;
  2196.                   case XbWDDb_Str:
  2197.                     {
  2198.                       char *ms;
  2199.                       char sstr[200];
  2200.                       int vtp,ii,ee;
  2201.                       int SL;
  2202.             
  2203.                       XbWFDb_GetInf((XbWDDb_DbIVar *)rw_itm, 0,
  2204.                         NULL, &vtp, &ms, &SL, 1);
  2205.             
  2206.                       strcpy(sstr,ms);
  2207.             
  2208.                       ee = 0;
  2209.                       for (ii=0; ii<SL; ii++) {
  2210.                         if (ee) {
  2211.                           sstr[ii] = ' ';
  2212.                           }
  2213.                         else {
  2214.                           switch (sstr[ii]) {
  2215.                             case 10: sstr[ii] = ' '; ee = 1; break;
  2216.                             case 13: sstr[ii] = ' '; ee = 1; break;
  2217.                             case  0: sstr[ii] = ' '; ee = 1; break;
  2218.                             };
  2219.                           };
  2220.                         };
  2221.                       sstr[SL] = 0;
  2222.             
  2223.                       if (!start_brace){ fprintf(fp,akt_return); };
  2224.                       fprintf(fp," \"%s\" ",sstr);
  2225.                       };
  2226.                     break;
  2227.                   default:;
  2228.                   };
  2229.                 };
  2230.               };
  2231.             break;
  2232.             /*}}}  */
  2233.           case XbWDDb_GPtr: rw_filitm = NULL; break;
  2234.           default:      rw_filitm = NULL; break;
  2235.           };
  2236.         akt_return = default_return;
  2237.         if (max_brace){
  2238.           max_brace--;
  2239.           start_brace=0;
  2240.           if (!max_brace){
  2241.             fprintf(fp,"}");
  2242.             };
  2243.           };
  2244.         };
  2245.       };
  2246.     
  2247.     fprintf(fp,"\n};\n\n");
  2248.     /*}}}  */
  2249.     };
  2250.   /*}}}  */
  2251.   fclose(fp);
  2252.  
  2253.   return(0);
  2254.   };
  2255. /*}}}  */
  2256. /*{{{  XbWFMx_RWGroup(     ***    Hauptroutine, ruft CrGrp und RWGrp*/
  2257. int  XbWFMx_RWGroup(void  *(*p)[], int (*t)[]){
  2258. #define rgr_apar (int)((*p)[0])
  2259.    char rgr_name[20];
  2260.    char fil_name[200];
  2261.    char rgr_rwm[200];
  2262.  
  2263. if (rgr_apar == 2) {
  2264.     char *tstr;
  2265.     strcpy(rgr_name,XbWFTb_PckTxt((char*)((*p)[2])));
  2266.     strcpy(rgr_rwm,XbWFTb_PckTxt((char*)((*p)[1])));
  2267.     tstr = rgr_rwm;
  2268.     switch (tstr[0]) {
  2269.       case 'C':
  2270.       case 'c':
  2271.         return(XbWFMx_CrGrp(rgr_name));
  2272.       default:
  2273.         return(XbWFMx_RWGrp(rgr_name,rgr_rwm,0,0,NULL));
  2274.       };
  2275.     };
  2276. if (rgr_apar == 4) {
  2277.   int v1,v2;
  2278.   strcpy(rgr_name,XbWFTb_PckTxt((char*)((*p)[2])));
  2279.   strcpy(rgr_rwm,XbWFTb_PckTxt((char*)((*p)[1])));
  2280.   switch ((int)(*t)[3]){
  2281.     case XbWDMf_VLPar:
  2282.       {
  2283.         XbWDDb_DbIVar  *MV;
  2284.         MV = (XbWDDb_DbIVar  *)(*p)[3];
  2285.         if (MV == NULL)  {return(1); };
  2286.         v1 = XbWFDb_GetNum(MV,NULL,1);
  2287.         };
  2288.       break;
  2289.     case XbWDMf_VPPar:
  2290.     case XbWDMf_IntPar: v1 = (int)(*p)[3]; break;
  2291.     default:return(1);
  2292.     };
  2293.   switch ((int)(*t)[4]){
  2294.     case XbWDMf_VLPar:
  2295.       {
  2296.         XbWDDb_DbIVar  *MV;
  2297.         MV = (XbWDDb_DbIVar  *)(*p)[4];
  2298.         if (MV == NULL)  {return(1); };
  2299.         v2 = XbWFDb_GetNum(MV,NULL,1);
  2300.         };
  2301.       break;
  2302.     case XbWDMf_VPPar:
  2303.     case XbWDMf_IntPar: v2 = (int)(*p)[4]; break;
  2304.     default:return(1);
  2305.     };
  2306.  
  2307.   {
  2308.     char *tstr = rgr_rwm;
  2309.     switch (tstr[0]) {
  2310.       case 'C':
  2311.       case 'c':
  2312.         return(XbWFMx_CrGrp(rgr_name));
  2313.       default:
  2314.         return(XbWFMx_RWGrp(rgr_name,rgr_rwm,v1,v2,NULL));
  2315.       };
  2316.     };
  2317.   };
  2318. if (rgr_apar == 3) {
  2319.   strcpy(rgr_name,XbWFTb_PckTxt((char*)((*p)[2])));
  2320.   strcpy(fil_name,XbWFTb_PckTxt((char*)((*p)[3])));
  2321.   strcpy(rgr_rwm,XbWFTb_PckTxt((char*)((*p)[1])));
  2322.   return(XbWFMx_RWGrp(rgr_name,rgr_rwm,0,0,fil_name));
  2323.   };
  2324. return(1);
  2325. };
  2326.  
  2327.  
  2328.  
  2329.  
  2330.  
  2331.  
  2332. /*}}}  */
  2333.  
  2334. /*{{{  XbWFDb_CDbIToPtr(         ***    Macht aus einer Datenbank-Pos. einen Pointer*/
  2335. XbWDDb_DbIVar  *XbWFDb_CDbIToPtr(XbWDDb_DbIPtr bb,void  *AP){
  2336.   return ((XbWDDb_DbIVar  *) (
  2337.     (char *)(AP)+(long)bb ));
  2338.   };
  2339. /*}}}  */
  2340. /*{{{  XbWFDb_ForWd(       ***    Ein Datenbank-Element vorwaerts*/
  2341. void  XbWFDb_ForWd(XbWDDb_DbIVar  **AP,XbWDDb_DbIVar  *IP){
  2342.   char  *tt;
  2343.   tt = (char  *)(*AP);
  2344.   tt = tt + (long)XbWFDb_GetSiz(*AP);
  2345.   *AP = (XbWDDb_DbIVar  *)tt;
  2346.   while(((*AP)->tp & XbWDDb_Typ) == XbWDDb_FPtr) {
  2347.     (*AP) = ((XbWDDb_DbIVar  *) ( (char *)(IP)+(long)(((XbWDDb_DbINPtr  *)(*AP))->inh) ));
  2348.     };
  2349.   };
  2350. /*}}}  */
  2351. /*{{{  XbWFDb_Fore(        ***    Speziell; im Prinzip wie ForWd*/
  2352. void  XbWFDb_Fore(XbWDDb_DbIVar  **AP,XbWDDb_DbIVar  *IP){
  2353.   char  *tt;
  2354.   while(((*AP)->tp & XbWDDb_Typ) == XbWDDb_FPtr) {
  2355.     (*AP) = ((XbWDDb_DbIVar  *) ( (char *)(IP)+(long)(((XbWDDb_DbINPtr  *)(*AP))->inh) ));
  2356.     };
  2357.   tt = (char  *)(*AP);
  2358.   tt = tt + (long)XbWFDb_GetSiz(*AP);
  2359.   *AP = (XbWDDb_DbIVar  *)tt;
  2360.   };
  2361. /*}}}  */
  2362. /*{{{  XbWFDb_PrInt(       ***    Integer-Element debuggen*/
  2363. void  XbWFDb_PrInt(FILE *fp, char *name, long adresse, long groesse, int inhalt){
  2364.   if (name[0] == 0) {
  2365.     fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Integer-parameter for command \"%s\")\n",
  2366.       adresse,groesse,name,inhalt,
  2367.       XbWVMf_LCmd);
  2368.     return;
  2369.     };
  2370.   if (name[1] == 0) {
  2371.     switch (name[0]) {
  2372.       case 'C':
  2373.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Command\t\"%s\")\n",
  2374.         adresse,groesse,name,inhalt,
  2375.         XbWVMf_com[inhalt]);
  2376.         XbWVMf_LCmd = XbWVMf_com[inhalt];
  2377.         return;
  2378.       case 'c':
  2379.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Parameter count for command\t\"%s\")\n",
  2380.         adresse,groesse,name,inhalt,
  2381.         XbWVMf_LCmd);
  2382.         return;
  2383.       case 'X':
  2384.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object X left top)\n",
  2385.         adresse,groesse,name,inhalt);
  2386.         return;
  2387.       case 'Y':
  2388.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object Y left top)\n",
  2389.         adresse,groesse,name,inhalt);
  2390.         return;
  2391.       case 'x':
  2392.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object X right bottom)\n",
  2393.         adresse,groesse,name,inhalt);
  2394.         return;
  2395.       case 'y':
  2396.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object Y right bottom)\n",
  2397.         adresse,groesse,name,inhalt);
  2398.         return;
  2399.       case 'b':
  2400.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object background color)\n",
  2401.         adresse,groesse,name,inhalt);
  2402.         return;
  2403.       case 'f':
  2404.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object bright (frame-) color)\n",
  2405.         adresse,groesse,name,inhalt);
  2406.         return;
  2407.       case 'F':
  2408.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object dark (frame-) color)\n",
  2409.         adresse,groesse,name,inhalt);
  2410.         return;
  2411.       case 't':
  2412.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object text color)\n",
  2413.         adresse,groesse,name,inhalt);
  2414.         return;
  2415.       case 'd':
  2416.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object display status)\n",
  2417.         adresse,groesse,name,inhalt);
  2418.         return;
  2419.       case 'e':
  2420.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object edit status)\n",
  2421.         adresse,groesse,name,inhalt);
  2422.         return;
  2423.       case 'w':
  2424.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object draw window after edit)\n",
  2425.         adresse,groesse,name,inhalt);
  2426.         return;
  2427.       case 'V':
  2428.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object VAR-PARAMETER INTEGER)\n",
  2429.         adresse,groesse,name,inhalt);
  2430.         return;
  2431.       case 'v':
  2432.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object default)\n",
  2433.         adresse,groesse,name,inhalt);
  2434.         return;
  2435.       case 'm':
  2436.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object minimum)\n",
  2437.         adresse,groesse,name,inhalt);
  2438.         return;
  2439.       case 'M':
  2440.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Object maximum)\n",
  2441.         adresse,groesse,name,inhalt);
  2442.         return;
  2443.       default:
  2444.         fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Integer)\n",
  2445.         adresse,groesse,name,inhalt);
  2446.         return;
  2447.       };
  2448.     };
  2449.   if (strlen(name) == 2) {
  2450.     if (strcmp(name,"sx") == 0) {
  2451.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: X-size in pixels)\n",
  2452.         adresse,groesse,name,inhalt);
  2453.       return;
  2454.       };
  2455.     if (strcmp(name,"sy") == 0) {
  2456.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: Y-size in pixels)\n",
  2457.         adresse,groesse,name,inhalt);
  2458.       return;
  2459.       };
  2460.     if (strcmp(name,"nx") == 0) {
  2461.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: X-position corner left top in pixels)\n",
  2462.         adresse,groesse,name,inhalt);
  2463.       return;
  2464.       };
  2465.     if (strcmp(name,"ny") == 0) {
  2466.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: Y-position corner left top in pixels)\n",
  2467.         adresse,groesse,name,inhalt);
  2468.       return;
  2469.       };
  2470.     if (strcmp(name,"tp") == 0) {
  2471.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: type)\n",
  2472.         adresse,groesse,name,inhalt);
  2473.       return;
  2474.       };
  2475.     if (strcmp(name,"bd") == 0) {
  2476.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: bkgd-draw 0=never 1=if!wov 2=if!icn 3=alw. +16=drawframe)\n",
  2477.         adresse,groesse,name,inhalt);
  2478.       return;
  2479.       };
  2480.     };
  2481.   if (strlen(name) == 3) {
  2482.     if (strcmp(name,"chg") == 0) {
  2483.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: if window has been changed. SYSTEM USE ONLY.)\n",
  2484.         adresse,groesse,name,inhalt);
  2485.       return;
  2486.       };
  2487.     if (strcmp(name,"wov") == 0) {
  2488.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: if window has been overwritten. SYSTEM USE ONLY.)\n",
  2489.         adresse,groesse,name,inhalt);
  2490.       return;
  2491.       };
  2492.     if (strcmp(name,"icn") == 0) {
  2493.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: if window has been iconized)\n",
  2494.         adresse,groesse,name,inhalt);
  2495.       return;
  2496.       };
  2497.     if (strcmp(name,"bkc") == 0) {
  2498.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: background color)\n",
  2499.         adresse,groesse,name,inhalt);
  2500.       return;
  2501.       };
  2502.     if (strcmp(name,"bfc") == 0) {
  2503.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: bright frame color)\n",
  2504.         adresse,groesse,name,inhalt);
  2505.       return;
  2506.       };
  2507.     if (strcmp(name,"dfc") == 0) {
  2508.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: dark frame color)\n",
  2509.         adresse,groesse,name,inhalt);
  2510.       return;
  2511.       };
  2512.     if (strcmp(name,"txc") == 0) {
  2513.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: text color)\n",
  2514.         adresse,groesse,name,inhalt);
  2515.       return;
  2516.       };
  2517.     if (strcmp(name,"wfx") == 0) {
  2518.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: if =1, do not leave window: WAIT FOR EXIT)\n",
  2519.         adresse,groesse,name,inhalt);
  2520.       return;
  2521.       };
  2522.     if (strcmp(name,"wfe") == 0) {
  2523.       fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: if =1 and object edited: set wfx = 1; WAIT FOR EDIT)\n",
  2524.         adresse,groesse,name,inhalt);
  2525.       return;
  2526.       };
  2527.     };
  2528.   if (strcmp(name,"layer") == 0) {
  2529.     fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Window: actual position vertical on screen)\n",
  2530.       adresse,groesse,name,inhalt);
  2531.     return;
  2532.     };
  2533.   fprintf(fp,"%5ld\ti\t%2ldsz\t\"%s\"\t\t%5d\t(Integer)\n",
  2534.       adresse,groesse,name,inhalt);
  2535.   return;
  2536.   };
  2537. /*}}}  */
  2538. /*{{{  XbWFDb_PrDbl(       ***    Double-Element debuggen*/
  2539. void  XbWFDb_PrDbl(FILE *fp, char *name, long adresse, long groesse, XbWDDb_DbIVar  *TV){
  2540.   if (name[0] == 0) {
  2541.     fprintf(fp,"%5ld\td\t%2ldsz\t\"%s\"\t\t%17.7f\t(Double-parameter for command \"%s\")\n",
  2542.       adresse,groesse,name,
  2543.       ((XbWDDb_DbIDbl *)TV)->inh,
  2544.       XbWVMf_LCmd);
  2545.     return;
  2546.     };
  2547.   if (name[1] == 0) {
  2548.     switch(name[0]){
  2549.       case 'V':
  2550.         fprintf(fp,"%5ld\td\t%2ldsz\t\"%s\"\t\t%17.7f\t(Object VAR-PARAMETER DOUBLE)\n",
  2551.           adresse,groesse,name,
  2552.           ((XbWDDb_DbIDbl *)TV)->inh);
  2553.         return;
  2554.       case 'v':
  2555.         fprintf(fp,"%5ld\td\t%2ldsz\t\"%s\"\t\t%17.7f\t(Object default)\n",
  2556.           adresse,groesse,name,
  2557.           ((XbWDDb_DbIDbl *)TV)->inh);
  2558.         return;
  2559.       case 'm':
  2560.         fprintf(fp,"%5ld\td\t%2ldsz\t\"%s\"\t\t%17.7f\t(Object minimum)\n",
  2561.           adresse,groesse,name,
  2562.           ((XbWDDb_DbIDbl *)TV)->inh);
  2563.         return;
  2564.       case 'M':
  2565.         fprintf(fp,"%5ld\td\t%2ldsz\t\"%s\"\t\t%17.7f\t(Object maximum)\n",
  2566.           adresse,groesse,name,
  2567.           ((XbWDDb_DbIDbl *)TV)->inh);
  2568.         return;
  2569.       default:
  2570.         fprintf(fp,"%5ld\td\t%2ldsz\t\"%s\"\t\t%17.7f\t(Double)\n",
  2571.           adresse,groesse,name,
  2572.           ((XbWDDb_DbIDbl *)TV)->inh);
  2573.         return;
  2574.       };
  2575.     };
  2576.   if (strlen(name) == 3){
  2577.     if (strcmp(name,"sca") == 0){
  2578.       fprintf(fp,"%5ld\td\t%2ldsz\t\"%s\"\t\t%17.7f\t(Objekt floating point scale)\n",
  2579.         adresse,groesse,name,
  2580.         ((XbWDDb_DbIDbl *)TV)->inh);
  2581.       return;
  2582.       };
  2583.     };
  2584.  
  2585.   fprintf(fp,"%5ld\td\t%2ldsz\t\"%s\"\t\t%17.7f\t(Double)\n",
  2586.     adresse,groesse,name,
  2587.     ((XbWDDb_DbIDbl *)TV)->inh);
  2588.   };
  2589.  
  2590. /*}}}  */
  2591. /*{{{  XbWFDb_PrPtr(       ***    Pointer-Element debuggen*/
  2592. void  XbWFDb_PrPtr(FILE *fp, char *name, long adresse, long groesse, XbWDDb_DbIVar  *TV){
  2593.   if (name[0] == 0) {
  2594.     fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer-parameter for command \"%s\")\n",
  2595.       adresse,groesse,name,
  2596.       ((XbWDDb_DbINPtr *)TV)->inh,
  2597.       XbWVMf_LCmd);
  2598.     return;
  2599.     };
  2600.   if (name[1] == 0) {
  2601.     switch(name[0]){
  2602.       case 'V':
  2603.         fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Object VAR-PARAMETER POINTER)\n",
  2604.           adresse,groesse,name,
  2605.           ((XbWDDb_DbINPtr *)TV)->inh);
  2606.         return;
  2607.       case 'W':
  2608.         fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to window name of object)\n",
  2609.           adresse,groesse,name,
  2610.           ((XbWDDb_DbINPtr *)TV)->inh);
  2611.         return;
  2612.       default:
  2613.         fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer)\n",
  2614.           adresse,groesse,name,
  2615.           ((XbWDDb_DbINPtr *)TV)->inh);
  2616.         return;
  2617.       };
  2618.     };
  2619.   if (strlen(name) == 3){
  2620.     if (strcmp(name,"OBJ") == 0) {
  2621.       fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to next object)\n",
  2622.           adresse,groesse,name,
  2623.           ((XbWDDb_DbINPtr *)TV)->inh);
  2624.       return;
  2625.       };
  2626.     if (strcmp(name,"obj") == 0) {
  2627.       fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Window: pointer to first object)\n",
  2628.           adresse,groesse,name,
  2629.           ((XbWDDb_DbINPtr *)TV)->inh);
  2630.       return;
  2631.       };
  2632.     if (strcmp(name,"WDW") == 0) {
  2633.       fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to next window)\n",
  2634.           adresse,groesse,name,
  2635.           ((XbWDDb_DbINPtr *)TV)->inh);
  2636.       return;
  2637.       };
  2638.     if (strcmp(name,"PRJ") == 0) {
  2639.       fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to next project)\n",
  2640.           adresse,groesse,name,
  2641.           ((XbWDDb_DbINPtr *)TV)->inh);
  2642.       return;
  2643.       };
  2644.     if (strcmp(name,"MFX") == 0) {
  2645.       fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to next MFX-group)\n",
  2646.           adresse,groesse,name,
  2647.           ((XbWDDb_DbINPtr *)TV)->inh);
  2648.       return;
  2649.       };
  2650.     if (strcmp(name,"KEY") == 0) {
  2651.       fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to next keyboard-group)\n",
  2652.           adresse,groesse,name,
  2653.           ((XbWDDb_DbINPtr *)TV)->inh);
  2654.       return;
  2655.       };
  2656.     if (strcmp(name,"OBX") == 0) {
  2657.       fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to next object generator variable group)\n",
  2658.           adresse,groesse,name,
  2659.           ((XbWDDb_DbINPtr *)TV)->inh);
  2660.       return;
  2661.       };
  2662.     if (strcmp(name,"SVR") == 0) {
  2663.       fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to next system variable group)\n",
  2664.           adresse,groesse,name,
  2665.           ((XbWDDb_DbINPtr *)TV)->inh);
  2666.       return;
  2667.       };
  2668.     if (strcmp(name,"USR") == 0) {
  2669.       fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to next user variable group)\n",
  2670.           adresse,groesse,name,
  2671.           ((XbWDDb_DbINPtr *)TV)->inh);
  2672.       return;
  2673.       };
  2674.     };
  2675.   fprintf(fp,"%5ld\tpn\t%2ldsz\t\"%s\"\t\t==> %lu\t(Pointer to VAR-Element)\n",
  2676.     adresse,groesse,name,
  2677.     ((XbWDDb_DbINPtr *)TV)->inh);
  2678.   };
  2679. /*}}}  */
  2680. /*{{{  XbWFDb_PrStr(       ***    String-Element debuggen*/
  2681. void  XbWFDb_PrStr(FILE *fp, char *name, long adresse, long groesse, XbWDDb_DbIVar  *TV){
  2682.   XbWDDb_DbIStr  *TS;
  2683.  
  2684.   TS = (XbWDDb_DbIStr *)TV;
  2685.  
  2686.   if (name[0] == 0) {
  2687.     fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t\t(String-Parameter for command \"%s\")\n",
  2688.       adresse,groesse,name,
  2689.       TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]),
  2690.       XbWVMf_LCmd);
  2691.     return;
  2692.     };
  2693.   if (name[1] == 0) {
  2694.     switch(name[0]){
  2695.       case 'M':
  2696.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Compiled Makro)\n",
  2697.           adresse,groesse,name,
  2698.           TS->len*2,"");
  2699.         return;
  2700.       case 'D':
  2701.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object display mode)\n",
  2702.           adresse,groesse,name,
  2703.           TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2704.         return;
  2705.       case 'E':
  2706.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object edit mode)\n",
  2707.           adresse,groesse,name,
  2708.           TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2709.         return;
  2710.       case 'V':
  2711.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object VAR-PARAMETER STRING)\n",
  2712.           adresse,groesse,name,
  2713.           TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2714.         return;
  2715.       case 'v':
  2716.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object default)\n",
  2717.           adresse,groesse,name,
  2718.           TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2719.         return;
  2720.       case 'i':
  2721.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object info text mode)\n",
  2722.           adresse,groesse,name,
  2723.           TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2724.         return;
  2725.       case 'T':
  2726.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object additional text)\n",
  2727.           adresse,groesse,name,
  2728.           TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2729.         return;
  2730.       case '1':
  2731.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(LIGHT-Object ON-text)\n",
  2732.           adresse,groesse,name,
  2733.           TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2734.         return;
  2735.       case '0':
  2736.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(LIGHT-Object OFF-text)\n",
  2737.           adresse,groesse,name,
  2738.           TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2739.         return;
  2740.       case 'W':
  2741.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object window name)\n",
  2742.           adresse,groesse,name,
  2743.           TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2744.         return;
  2745.       default:
  2746.         fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(String)\n",
  2747.           adresse,groesse,name,
  2748.           TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2749.         return;
  2750.       };
  2751.     };
  2752.   if (strlen(name) == 3){
  2753.     if (strcmp(name,"inf") == 0) {
  2754.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Window: file name for help text)\n",
  2755.         adresse,groesse,name,
  2756.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2757.       return;
  2758.       };
  2759.     if (strcmp(name,"OBJ") == 0) {
  2760.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object name)\n",
  2761.         adresse,groesse,name,
  2762.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2763.       return;
  2764.       };
  2765.     if (strcmp(name,"WDW") == 0) {
  2766.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Window name)\n",
  2767.         adresse,groesse,name,
  2768.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2769.       return;
  2770.       };
  2771.     if (strcmp(name,"PRJ") == 0) {
  2772.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Project name)\n",
  2773.         adresse,groesse,name,
  2774.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2775.       return;
  2776.       };
  2777.     if (strcmp(name,"SVR") == 0) {
  2778.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(System variable group name)\n",
  2779.         adresse,groesse,name,
  2780.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2781.       return;
  2782.       };
  2783.     if (strcmp(name,"OBX") == 0) {
  2784.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object generator variable group name)\n",
  2785.         adresse,groesse,name,
  2786.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2787.       return;
  2788.       };
  2789.     if (strcmp(name,"USR") == 0) {
  2790.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(User variable group name)\n",
  2791.         adresse,groesse,name,
  2792.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2793.       return;
  2794.       };
  2795.     if (strcmp(name,"MFX") == 0) {
  2796.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(MFX variable group name)\n",
  2797.         adresse,groesse,name,
  2798.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2799.       return;
  2800.       };
  2801.     if (strcmp(name,"KEY") == 0) {
  2802.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Keyboard variable group name)\n",
  2803.         adresse,groesse,name,
  2804.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2805.       return;
  2806.       };
  2807.     if (strcmp(name,"fmt") == 0) {
  2808.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object floating point format)\n",
  2809.         adresse,groesse,name,
  2810.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2811.       return;
  2812.       };
  2813.     if (strcmp(name,"eha") == 0) {
  2814.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object floating point unit)\n",
  2815.         adresse,groesse,name,
  2816.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2817.       return;
  2818.       };
  2819.     if (strcmp(name,"epO") == 0) {
  2820.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object to edit PREVIOUSLY)\n",
  2821.         adresse,groesse,name,
  2822.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2823.       return;
  2824.       };
  2825.     if (strcmp(name,"rbK") == 0) {
  2826.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: makro to read before edit)\n",
  2827.         adresse,groesse,name,
  2828.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2829.       return;
  2830.       };
  2831.     if (strcmp(name,"ebO") == 0) {
  2832.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: object to edit before edit)\n",
  2833.         adresse,groesse,name,
  2834.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2835.       return;
  2836.       };
  2837.     if (strcmp(name,"wbX") == 0) {
  2838.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: mfx-file to write before edit)\n",
  2839.         adresse,groesse,name,
  2840.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2841.       return;
  2842.       };
  2843.     if (strcmp(name,"rbT") == 0) {
  2844.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: meta-file to read before edit)\n",
  2845.         adresse,groesse,name,
  2846.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2847.       return;
  2848.       };
  2849.     if (strcmp(name,"rbC") == 0) {
  2850.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: compiled makro to read before edit)\n",
  2851.         adresse,groesse,name,
  2852.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2853.       return;
  2854.       };
  2855.     if (strcmp(name,"raX") == 0) {
  2856.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: mfx-file to read after edit)\n",
  2857.         adresse,groesse,name,
  2858.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2859.       return;
  2860.       };
  2861.     if (strcmp(name,"raT") == 0) {
  2862.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: meta-file to read after edit)\n",
  2863.         adresse,groesse,name,
  2864.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2865.       return;
  2866.       };
  2867.     if (strcmp(name,"raK") == 0) {
  2868.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: makro to read after edit)\n",
  2869.         adresse,groesse,name,
  2870.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2871.       return;
  2872.       };
  2873.     if (strcmp(name,"edO") == 0) {
  2874.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: object to edit after edit)\n",
  2875.         adresse,groesse,name,
  2876.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2877.       return;
  2878.       };
  2879.     if (strcmp(name,"raC") == 0) {
  2880.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: compiled makro to read after edit)\n",
  2881.         adresse,groesse,name,
  2882.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2883.       return;
  2884.       };
  2885.     if (strcmp(name,"dpO") == 0) {
  2886.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: object to display after edit)\n",
  2887.         adresse,groesse,name,
  2888.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2889.       return;
  2890.       };
  2891.     if (strcmp(name,"rqX") == 0) {
  2892.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: mfx-file to read after queue)\n",
  2893.         adresse,groesse,name,
  2894.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2895.       return;
  2896.       };
  2897.     if (strcmp(name,"rqT") == 0) {
  2898.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: meta-file to read after queue)\n",
  2899.         adresse,groesse,name,
  2900.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2901.       return;
  2902.       };
  2903.     if (strcmp(name,"rqK") == 0) {
  2904.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: makro to read after queue)\n",
  2905.         adresse,groesse,name,
  2906.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2907.       return;
  2908.       };
  2909.     if (strcmp(name,"eqO") == 0) {
  2910.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: object to edit after queue)\n",
  2911.         adresse,groesse,name,
  2912.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2913.       return;
  2914.       };
  2915.     if (strcmp(name,"rqC") == 0) {
  2916.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: compiled makro to read after queue)\n",
  2917.         adresse,groesse,name,
  2918.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2919.       return;
  2920.       };
  2921.     if (strcmp(name,"dqO") == 0) {
  2922.       fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(Object: object to display after queue)\n",
  2923.         adresse,groesse,name,
  2924.         TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2925.       return;
  2926.       };
  2927.     };
  2928.   fprintf(fp,"%5ld\ts\t%2ldsz\t\"%s\"\t\t(%d unsigned chars)\t\"%s\"\t(String)\n",
  2929.     adresse,groesse,name,
  2930.     TS->len*2,&(TS->nmi[(TS->tp & XbWDDb_NLen)]));
  2931.   return;
  2932.   };
  2933. /*}}}  */
  2934.  
  2935.